diff --git a/examples_tests b/examples_tests
index e4906b5ab..73ac5c8aa 160000
--- a/examples_tests
+++ b/examples_tests
@@ -1 +1 @@
-Subproject commit e4906b5ab6187ab1be4a34df9f3eef8002366a27
+Subproject commit 73ac5c8aaabb4a33c46599de51ad2a5d5fff77cc
diff --git a/include/nbl/builtin/hlsl/array_accessors.hlsl b/include/nbl/builtin/hlsl/array_accessors.hlsl
new file mode 100644
index 000000000..b025f9d67
--- /dev/null
+++ b/include/nbl/builtin/hlsl/array_accessors.hlsl
@@ -0,0 +1,30 @@
+#ifndef _NBL_BUILTIN_HLSL_ARRAY_ACCESSORS_HLSL_INCLUDED_
+#define _NBL_BUILTIN_HLSL_ARRAY_ACCESSORS_HLSL_INCLUDED_
+
+#include <nbl/builtin/hlsl/cpp_compat/basic.h>
+
+namespace nbl
+{
+namespace hlsl
+{
+template<typename ArrayType, typename ComponentType, typename I = uint32_t>
+struct array_get
+{
+    ComponentType operator()(NBL_CONST_REF_ARG(ArrayType) arr, const I ix) NBL_CONST_MEMBER_FUNC
+    {
+        return arr[ix];
+    }
+};
+
+template<typename ArrayType, typename ComponentType, typename I = uint32_t>
+struct array_set
+{
+    void operator()(NBL_REF_ARG(ArrayType) arr, I index, ComponentType val) NBL_CONST_MEMBER_FUNC
+    {
+        arr[index] = val;
+    }
+};
+}
+}
+
+#endif
\ No newline at end of file
diff --git a/include/nbl/builtin/hlsl/cpp_compat.hlsl b/include/nbl/builtin/hlsl/cpp_compat.hlsl
index 2d8a13e63..175a3e76c 100644
--- a/include/nbl/builtin/hlsl/cpp_compat.hlsl
+++ b/include/nbl/builtin/hlsl/cpp_compat.hlsl
@@ -3,7 +3,7 @@
 
 #include <nbl/builtin/hlsl/cpp_compat/basic.h>
 // it includes vector and matrix
-#include <nbl/builtin/hlsl/cpp_compat/intrinsics.h>
+#include <nbl/builtin/hlsl/cpp_compat/intrinsics.hlsl>
 #include <nbl/builtin/hlsl/cpp_compat/promote.hlsl>
 
 #endif
\ No newline at end of file
diff --git a/include/nbl/builtin/hlsl/cpp_compat/basic.h b/include/nbl/builtin/hlsl/cpp_compat/basic.h
index 8788794cc..402a640cf 100644
--- a/include/nbl/builtin/hlsl/cpp_compat/basic.h
+++ b/include/nbl/builtin/hlsl/cpp_compat/basic.h
@@ -55,8 +55,12 @@ namespace nbl::hlsl
 
 // We need variadic macro in order to handle multi parameter templates because the 
 // preprocessor parses the template parameters as different macro parameters.
-#define NBL_REF_ARG(...) typename nbl::hlsl::add_reference<__VA_ARGS__ >::type
-#define NBL_CONST_REF_ARG(...) typename nbl::hlsl::add_reference<std::add_const_t<__VA_ARGS__ >>::type
+#define NBL_REF_ARG(...) __VA_ARGS__&
+#define NBL_CONST_REF_ARG(...) const __VA_ARGS__&
+
+// NOTE: implementation below will mess up template parameter deduction
+//#define NBL_REF_ARG(...) typename nbl::hlsl::add_reference<__VA_ARGS__ >::type
+//#define NBL_CONST_REF_ARG(...) typename nbl::hlsl::add_reference<std::add_const_t<__VA_ARGS__ >>::type
 
 #else
 
diff --git a/include/nbl/builtin/hlsl/cpp_compat/impl/intrinsics_impl.hlsl b/include/nbl/builtin/hlsl/cpp_compat/impl/intrinsics_impl.hlsl
new file mode 100644
index 000000000..236544076
--- /dev/null
+++ b/include/nbl/builtin/hlsl/cpp_compat/impl/intrinsics_impl.hlsl
@@ -0,0 +1,369 @@
+#ifndef _NBL_BUILTIN_HLSL_CPP_COMPAT_IMPL_INTRINSICS_IMPL_INCLUDED_
+#define _NBL_BUILTIN_HLSL_CPP_COMPAT_IMPL_INTRINSICS_IMPL_INCLUDED_
+
+#include <nbl/builtin/hlsl/cpp_compat/basic.h>
+#include <nbl/builtin/hlsl/concepts.hlsl>
+
+namespace nbl
+{
+namespace hlsl
+{
+namespace cpp_compat_intrinsics_impl
+{
+template<typename T>
+struct dot_helper
+{
+	using scalar_type = typename vector_traits<T>::scalar_type;
+
+	static inline scalar_type dot_product(NBL_CONST_REF_ARG(T) lhs, NBL_CONST_REF_ARG(T) rhs)
+	{
+		static array_get<T, scalar_type> getter;
+		scalar_type retval = getter(lhs, 0) * getter(rhs, 0);
+
+		static const uint32_t ArrayDim = sizeof(T) / sizeof(scalar_type);
+		for (uint32_t i = 1; i < ArrayDim; ++i)
+			retval = retval + getter(lhs, i) * getter(rhs, i);
+
+		return retval;
+	}
+};
+
+#define DEFINE_BUILTIN_VECTOR_SPECIALIZATION(FLOAT_TYPE, RETURN_VALUE)\
+template<uint32_t N>\
+struct dot_helper<vector<FLOAT_TYPE, N> >\
+{\
+	using VectorType = vector<FLOAT_TYPE, N>;\
+	using ScalarType = typename vector_traits<VectorType>::scalar_type;\
+\
+	static inline ScalarType dot_product(NBL_CONST_REF_ARG(VectorType) lhs, NBL_CONST_REF_ARG(VectorType) rhs)\
+	{\
+		return RETURN_VALUE;\
+	}\
+};\
+
+#ifdef __HLSL_VERSION
+#define BUILTIN_VECTOR_SPECIALIZATION_RET_VAL dot(lhs, rhs)
+#else
+#define BUILTIN_VECTOR_SPECIALIZATION_RET_VAL glm::dot(lhs, rhs)
+#endif
+
+DEFINE_BUILTIN_VECTOR_SPECIALIZATION(float16_t, BUILTIN_VECTOR_SPECIALIZATION_RET_VAL)
+DEFINE_BUILTIN_VECTOR_SPECIALIZATION(float32_t, BUILTIN_VECTOR_SPECIALIZATION_RET_VAL)
+DEFINE_BUILTIN_VECTOR_SPECIALIZATION(float64_t, BUILTIN_VECTOR_SPECIALIZATION_RET_VAL)
+
+#undef BUILTIN_VECTOR_SPECIALIZATION_RET_VAL
+#undef DEFINE_BUILTIN_VECTOR_SPECIALIZATION
+
+template<typename Integer>
+struct find_msb_helper;
+
+template<>
+struct find_msb_helper<uint32_t>
+{
+	static int32_t findMSB(NBL_CONST_REF_ARG(uint32_t) val)
+	{
+#ifdef __HLSL_VERSION
+		return spirv::findUMsb(val);
+#else
+		return glm::findMSB(val);
+#endif
+	}
+};
+
+template<>
+struct find_msb_helper<int32_t>
+{
+	static int32_t findMSB(NBL_CONST_REF_ARG(int32_t) val)
+	{
+#ifdef __HLSL_VERSION
+		return spirv::findSMsb(val);
+#else
+		return glm::findMSB(val);
+#endif
+	}
+};
+
+#define DEFINE_FIND_MSB_COMMON_SPECIALIZATION(INPUT_INTEGER_TYPE, INTEGER_TYPE)\
+template<>\
+struct find_msb_helper<INPUT_INTEGER_TYPE>\
+{\
+	static int32_t findMSB(NBL_CONST_REF_ARG(INPUT_INTEGER_TYPE) val)\
+	{\
+		return find_msb_helper<INTEGER_TYPE>::findMSB(val);\
+	}\
+};\
+
+DEFINE_FIND_MSB_COMMON_SPECIALIZATION(int16_t, int32_t)
+DEFINE_FIND_MSB_COMMON_SPECIALIZATION(uint16_t, uint32_t)
+#ifndef __HLSL_VERSION
+DEFINE_FIND_MSB_COMMON_SPECIALIZATION(int8_t, int32_t)
+DEFINE_FIND_MSB_COMMON_SPECIALIZATION(uint8_t, uint32_t)
+#endif
+
+template<>
+struct find_msb_helper<uint64_t>
+{
+	static int32_t findMSB(NBL_CONST_REF_ARG(uint64_t) val)
+	{
+#ifdef __HLSL_VERSION
+		const uint32_t highBits = uint32_t(val >> 32);
+		const int32_t highMsb = find_msb_helper<uint32_t>::findMSB(highBits);
+
+		if (highMsb == -1)
+		{
+			const uint32_t lowBits = uint32_t(val);
+			const int32_t lowMsb = find_msb_helper<uint32_t>::findMSB(lowBits);
+			if (lowMsb == -1)
+				return -1;
+
+			return lowMsb;
+		}
+
+		return highMsb + 32;
+#else
+		return glm::findMSB(val);
+#endif
+	}
+};
+
+template<int N>
+struct find_msb_helper<vector<uint32_t, N> >
+{
+	static vector<int32_t, N> findMSB(NBL_CONST_REF_ARG(vector<uint32_t, N>) val)
+	{
+#ifdef __HLSL_VERSION
+		return spirv::findUMsb(val);
+#else
+		return glm::findMSB(val);
+#endif
+	}
+};
+
+template<int N>
+struct find_msb_helper<vector<int32_t, N> >
+{
+	static vector<int32_t, N> findMSB(NBL_CONST_REF_ARG(vector<int32_t, N>) val)
+	{
+#ifdef __HLSL_VERSION
+		return spirv::findSMsb(val);
+#else
+		return glm::findMSB(val);
+#endif
+	}
+};
+
+#ifndef __HLSL_VERSION
+
+template<typename EnumType>
+	requires std::is_enum_v<EnumType>
+struct find_msb_helper<EnumType>
+{
+	static int32_t findMSB(NBL_CONST_REF_ARG(EnumType) val)
+	{
+		using underlying_t = std::underlying_type_t<EnumType>;
+		return find_msb_helper<underlying_t>::findMSB(static_cast<underlying_t>(val));
+	}
+};
+
+#endif
+
+template<typename Integer>
+struct find_lsb_helper;
+
+template<>
+struct find_lsb_helper<int32_t>
+{
+	static int32_t findLSB(NBL_CONST_REF_ARG(int32_t) val)
+	{
+#ifdef __HLSL_VERSION
+		return spirv::findILsb(val);
+#else
+		return glm::findLSB(val);
+#endif
+	}
+};
+
+template<>
+struct find_lsb_helper<uint32_t>
+{
+	static int32_t findLSB(NBL_CONST_REF_ARG(uint32_t) val)
+	{
+#ifdef __HLSL_VERSION
+		return spirv::findILsb(val);
+#else
+		return glm::findLSB(val);
+#endif
+	}
+};
+
+#define DEFINE_FIND_LSB_COMMON_SPECIALIZATION(INPUT_INTEGER_TYPE, INTEGER_TYPE)\
+template<>\
+struct find_lsb_helper<INPUT_INTEGER_TYPE>\
+{\
+	static int32_t findLSB(NBL_CONST_REF_ARG(INPUT_INTEGER_TYPE) val)\
+	{\
+		return find_lsb_helper<INTEGER_TYPE>::findLSB(val);\
+	}\
+};\
+
+DEFINE_FIND_LSB_COMMON_SPECIALIZATION(int16_t, int32_t)
+DEFINE_FIND_LSB_COMMON_SPECIALIZATION(uint16_t, uint32_t)
+#ifndef __HLSL_VERSION
+DEFINE_FIND_LSB_COMMON_SPECIALIZATION(int8_t, int32_t)
+DEFINE_FIND_LSB_COMMON_SPECIALIZATION(uint8_t, uint32_t)
+#endif
+
+template<>
+struct find_lsb_helper<uint64_t>
+{
+	static int32_t findLSB(NBL_CONST_REF_ARG(uint64_t) val)
+	{
+#ifdef __HLSL_VERSION
+		const uint32_t lowBits = uint32_t(val);
+		const int32_t lowLsb = find_lsb_helper<uint32_t>::findLSB(lowBits);
+
+		if (lowLsb == -1)
+		{
+			const uint32_t highBits = uint32_t(val >> 32);
+			const int32_t highLsb = find_lsb_helper<uint32_t>::findLSB(highBits);
+			if (highLsb == -1)
+				return -1;
+			else
+				return 32 + highLsb;
+		}
+
+		return lowLsb;
+#else
+		return glm::findLSB(val);
+#endif
+	}
+};
+
+template<int N>
+struct find_lsb_helper<vector<int32_t, N> >
+{
+	static vector<int32_t, N> findLSB(NBL_CONST_REF_ARG(vector<int32_t, N>) val)
+	{
+#ifdef __HLSL_VERSION
+		return spirv::findILsb(val);
+#else
+		return glm::findLSB(val);
+#endif
+	}
+};
+
+template<int N>
+struct find_lsb_helper<vector<uint32_t, N> >
+{
+	static vector<int32_t, N> findLSB(NBL_CONST_REF_ARG(vector<uint32_t, N>) val)
+	{
+#ifdef __HLSL_VERSION
+		return spirv::findILsb(val);
+#else
+		return glm::findLSB(val);
+#endif
+	}
+};
+
+#ifndef __HLSL_VERSION
+
+template<typename EnumType>
+requires std::is_enum_v<EnumType>
+struct find_lsb_helper<EnumType>
+{
+	static int32_t findLSB(NBL_CONST_REF_ARG(EnumType) val)
+	{
+		using underlying_t = std::underlying_type_t<EnumType>;
+		return find_lsb_helper<underlying_t>::findLSB(static_cast<underlying_t>(val));
+	}
+};
+
+#endif
+
+template<typename Integer>
+struct find_msb_return_type
+{
+	using type = int32_t;
+};
+template<typename Integer, int N>
+struct find_msb_return_type<vector<Integer, N> >
+{
+	using type = vector<int32_t, N>;
+};
+template<typename Integer>
+using find_lsb_return_type = find_msb_return_type<Integer>;
+
+template<typename T, typename U NBL_STRUCT_CONSTRAINABLE>
+struct lerp_helper;
+
+#ifdef __HLSL_VERSION
+#define MIX_FUNCTION spirv::fMix
+#else
+#define MIX_FUNCTION glm::mix
+#endif
+
+#define DEFINE_LERP_HELPER_COMMON_SPECIALIZATION(TYPE)\
+template<>\
+struct lerp_helper<TYPE, TYPE>\
+{\
+	static inline TYPE lerp(NBL_CONST_REF_ARG(TYPE) x, NBL_CONST_REF_ARG(TYPE) y, NBL_CONST_REF_ARG(TYPE) a)\
+	{\
+		return MIX_FUNCTION(x, y, a);\
+	}\
+};\
+\
+template<int N>\
+struct lerp_helper<vector<TYPE, N>, vector<TYPE, N> >\
+{\
+	static inline vector<TYPE, N> lerp(NBL_CONST_REF_ARG(vector<TYPE, N>) x, NBL_CONST_REF_ARG(vector<TYPE, N>) y, NBL_CONST_REF_ARG(vector<TYPE, N>) a)\
+	{\
+		return MIX_FUNCTION(x, y, a);\
+	}\
+};\
+\
+template<int N>\
+struct lerp_helper<vector<TYPE, N>, TYPE>\
+{\
+	static inline vector<TYPE, N> lerp(NBL_CONST_REF_ARG(vector<TYPE, N>) x, NBL_CONST_REF_ARG(vector<TYPE, N>) y, NBL_CONST_REF_ARG(TYPE) a)\
+	{\
+		return MIX_FUNCTION(x, y, a);\
+	}\
+};\
+
+DEFINE_LERP_HELPER_COMMON_SPECIALIZATION(float32_t)
+DEFINE_LERP_HELPER_COMMON_SPECIALIZATION(float64_t)
+
+#undef DEFINE_LERP_HELPER_COMMON_SPECIALIZATION
+#undef MIX_FUNCTION
+
+template<typename T>
+struct lerp_helper<T, bool>
+{
+	static inline T lerp(NBL_CONST_REF_ARG(T) x, NBL_CONST_REF_ARG(T) y, NBL_CONST_REF_ARG(bool) a)
+	{
+		if (a)
+			return y;
+		else
+			return x;
+	}
+};
+
+template<typename T, int N>
+struct lerp_helper<vector<T, N>, vector<bool, N> >
+{
+	using output_vec_t = vector<T, N>;
+
+	static inline output_vec_t lerp(NBL_CONST_REF_ARG(output_vec_t) x, NBL_CONST_REF_ARG(output_vec_t) y, NBL_CONST_REF_ARG(vector<bool, N>) a)
+	{
+		output_vec_t retval;
+		for (uint32_t i = 0; i < vector_traits<output_vec_t>::Dimension; i++)
+			retval[i] = a[i] ? y[i] : x[i];
+		return retval;
+	}
+};
+
+}
+}
+}
+
+#endif
\ No newline at end of file
diff --git a/include/nbl/builtin/hlsl/cpp_compat/intrinsics.h b/include/nbl/builtin/hlsl/cpp_compat/intrinsics.h
deleted file mode 100644
index e83ced0bc..000000000
--- a/include/nbl/builtin/hlsl/cpp_compat/intrinsics.h
+++ /dev/null
@@ -1,144 +0,0 @@
-#ifndef _NBL_BUILTIN_HLSL_CPP_COMPAT_INTRINSICS_INCLUDED_
-#define _NBL_BUILTIN_HLSL_CPP_COMPAT_INTRINSICS_INCLUDED_
-
-
-#include <nbl/builtin/hlsl/cpp_compat/matrix.hlsl>
-#include <nbl/builtin/hlsl/type_traits.hlsl>
-
-// this is a C++ only header, hence the `.h` extension, it only implements HLSL's built-in functions
-#ifndef __HLSL_VERSION
-#include <algorithm>
-#include <cmath>
-#include "nbl/core/util/bitflag.h"
-
-namespace nbl::hlsl
-{
-// TODO: remove this macro and write stuff by hand, the aliasing stuff doesn't work
-#define NBL_SIMPLE_GLM_PASSTHROUGH(HLSL_ID,GLSL_ID,...) template<typename... Args>\
-inline auto HLSL_ID(Args&&... args) \
-{ \
-    return glm::GLSL_ID(std::forward<Args>(args)...);\
-}
-#define NBL_BIT_OP_GLM_PASSTHROUGH(HLSL_ID,GLSL_ID) template<typename T> \
-inline auto HLSL_ID(const T bitpattern) \
-{ \
-    if constexpr (std::is_integral_v<T>) \
-        return glm::GLSL_ID(bitpattern); \
-    else \
-    { \
-        if constexpr (std::is_enum_v<T>) \
-        { \
-            const auto as_underlying = static_cast<std::underlying_type_t<T>>(bitpattern); \
-            return glm::GLSL_ID(as_underlying); \
-        } \
-        else \
-        { \
-            if constexpr (std::is_same_v<T,core::bitflag<typename T::enum_t>>) \
-                return HLSL_ID<typename T::enum_t>(bitpattern.value); \
-        } \
-    } \
-}
-
-NBL_BIT_OP_GLM_PASSTHROUGH(bitCount,bitCount)
-
-NBL_SIMPLE_GLM_PASSTHROUGH(cross,cross)
-NBL_SIMPLE_GLM_PASSTHROUGH(clamp,clamp)
-
-template<typename T>
-inline scalar_type_t<T> dot(const T& lhs, const T& rhs)
-{
-    scalar_type_t<T> retval = lhs[0]*rhs[0];
-    // whatever has a `scalar_type` specialization should be a pure vector
-    for (auto i=1; i<sizeof(T)/sizeof(retval); i++)
-        retval += lhs[i]*rhs[i];
-    return retval;
-}
-
-// determinant not defined cause its implemented via hidden friend
-// https://stackoverflow.com/questions/67459950/why-is-a-friend-function-not-treated-as-a-member-of-a-namespace-of-a-class-it-wa
-template<typename T, uint16_t N, uint16_t M>
-inline T determinant(const matrix<T,N,M>& m)
-{
-    return glm::determinant(reinterpret_cast<typename matrix<T,N,M>::Base const&>(m));
-}
-
-NBL_BIT_OP_GLM_PASSTHROUGH(findLSB,findLSB)
-
-NBL_BIT_OP_GLM_PASSTHROUGH(findMSB,findMSB)
-
-// TODO: some of the functions in this header should move to `tgmath`
-template<typename T> requires ::nbl::hlsl::is_floating_point_v<T>
-inline T floor(const T& v)
-{
-    return glm::floor(v);
-}
-
-
-// inverse not defined cause its implemented via hidden friend
-template<typename T, uint16_t N, uint16_t M>
-inline matrix<T,N,M> inverse(const matrix<T,N,M>& m)
-{
-    return reinterpret_cast<matrix<T,N,M>&>(glm::inverse(reinterpret_cast<typename matrix<T,N,M>::Base const&>(m)));
-}
-
-template<typename T, typename U>
-inline T lerp(const T& x, const T& y, const U& a)
-{
-    if constexpr (std::is_same_v<U,bool>)
-        return a ? y:x;
-    else
-    {
-        if constexpr (std::is_same_v<scalar_type_t<U>,bool>)
-        {
-            T retval;
-            // whatever has a `scalar_type` specialization should be a pure vector
-            for (auto i=0; i<sizeof(a)/sizeof(scalar_type_t<U>); i++)
-                retval[i] = a[i] ? y[i]:x[i];
-            return retval;
-        }
-        else
-            return glm::mix<T,U>(x,y,a);
-    }
-}
-
-// transpose not defined cause its implemented via hidden friend
-template<typename T, uint16_t N, uint16_t M>
-inline matrix<T,M,N> transpose(const matrix<T,N,M>& m)
-{
-    return reinterpret_cast<matrix<T,M,N>&>(glm::transpose(reinterpret_cast<typename matrix<T,N,M>::Base const&>(m)));
-}
-
-#undef NBL_BIT_OP_GLM_PASSTHROUGH
-#undef NBL_SIMPLE_GLM_PASSTHROUGH
-
-// TODO: remove this macro and write stuff by hand, the aliasing stuff doesn't work
-#define NBL_ALIAS_TEMPLATE_FUNCTION(origFunctionName, functionAlias) \
-template<typename... Args> \
-inline auto functionAlias(Args&&... args) -> decltype(origFunctionName(std::forward<Args>(args)...)) \
-{ \
-    return origFunctionName(std::forward<Args>(args)...); \
-}
-
-NBL_ALIAS_TEMPLATE_FUNCTION(std::min, min);
-
-template<typename T>
-inline T max(const T& a, const T& b)
-{
-    return lerp<T>(a,b,b>a);
-}
-
-NBL_ALIAS_TEMPLATE_FUNCTION(std::isnan, isnan);
-NBL_ALIAS_TEMPLATE_FUNCTION(std::isinf, isinf);
-NBL_ALIAS_TEMPLATE_FUNCTION(std::exp2, exp2);
-
-template<typename T>
-inline T rsqrt(T x)
-{
-    return 1.0f / std::sqrt(x);
-}
-
-
-}
-#endif
-
-#endif
diff --git a/include/nbl/builtin/hlsl/cpp_compat/intrinsics.hlsl b/include/nbl/builtin/hlsl/cpp_compat/intrinsics.hlsl
new file mode 100644
index 000000000..87e3f6712
--- /dev/null
+++ b/include/nbl/builtin/hlsl/cpp_compat/intrinsics.hlsl
@@ -0,0 +1,212 @@
+#ifndef _NBL_BUILTIN_HLSL_CPP_COMPAT_INTRINSICS_INCLUDED_
+#define _NBL_BUILTIN_HLSL_CPP_COMPAT_INTRINSICS_INCLUDED_
+
+#include <nbl/builtin/hlsl/cpp_compat/matrix.hlsl>
+#include <nbl/builtin/hlsl/type_traits.hlsl>
+#include <nbl/builtin/hlsl/vector_utils/vector_traits.hlsl>
+#include <nbl/builtin/hlsl/array_accessors.hlsl>
+#include <nbl/builtin/hlsl/spirv_intrinsics/core.hlsl>
+#include <nbl/builtin/hlsl/spirv_intrinsics/glsl.std.450.hlsl>
+#include <nbl/builtin/hlsl/cpp_compat/impl/intrinsics_impl.hlsl>
+
+#ifndef __HLSL_VERSION
+#include <algorithm>
+#include <cmath>
+#include "nbl/core/util/bitflag.h"
+#endif
+
+namespace nbl
+{
+namespace hlsl
+{
+
+template<typename Integer>
+inline int bitCount(NBL_CONST_REF_ARG(Integer) val)
+{
+#ifdef __HLSL_VERSION
+	if (sizeof(Integer) == 8u)
+	{
+		uint32_t lowBits = uint32_t(val);
+		uint32_t highBits = uint32_t(uint64_t(val) >> 32u);
+
+		return countbits(lowBits) + countbits(highBits);
+	}
+
+	return countbits(val);
+
+#else
+	return glm::bitCount(val);
+#endif
+}
+
+template<typename T>
+vector<T, 3> cross(NBL_CONST_REF_ARG(vector<T, 3>) lhs, NBL_CONST_REF_ARG(vector<T, 3>) rhs)
+{
+#ifdef __HLSL_VERSION
+	return spirv::cross(lhs, rhs);
+#else
+	return glm::cross(lhs, rhs);
+#endif
+}
+
+template<typename T>
+T clamp(NBL_CONST_REF_ARG(T) val, NBL_CONST_REF_ARG(T) min, NBL_CONST_REF_ARG(T) max)
+{
+#ifdef __HLSL_VERSION
+	return clamp(val, min, max);
+#else
+	return glm::clamp(val, min, max);
+#endif
+}
+
+template<typename T>
+typename vector_traits<T>::scalar_type dot(NBL_CONST_REF_ARG(T) lhs, NBL_CONST_REF_ARG(T) rhs)
+{
+	return cpp_compat_intrinsics_impl::dot_helper<T>::dot_product(lhs, rhs);
+}
+
+// TODO: for clearer error messages, use concepts to ensure that input type is a square matrix
+// determinant not defined cause its implemented via hidden friend
+// https://stackoverflow.com/questions/67459950/why-is-a-friend-function-not-treated-as-a-member-of-a-namespace-of-a-class-it-wa
+template<typename T, uint16_t N>
+inline T determinant(NBL_CONST_REF_ARG(matrix<T, N, N>) m)
+{
+#ifdef __HLSL_VERSION
+	spirv::determinant(m);
+#else
+	return glm::determinant(reinterpret_cast<typename matrix<T, N, N>::Base const&>(m));
+#endif
+}
+
+template<typename Integer>
+inline typename cpp_compat_intrinsics_impl::find_lsb_return_type<Integer>::type findLSB(NBL_CONST_REF_ARG(Integer) val)
+{
+	return cpp_compat_intrinsics_impl::find_lsb_helper<Integer>::findLSB(val);
+}
+
+template<typename Integer>
+inline typename cpp_compat_intrinsics_impl::find_msb_return_type<Integer>::type findMSB(NBL_CONST_REF_ARG(Integer) val)
+{
+	return cpp_compat_intrinsics_impl::find_msb_helper<Integer>::findMSB(val);
+}
+
+// TODO: some of the functions in this header should move to `tgmath`
+template<typename T>
+inline T floor(NBL_CONST_REF_ARG(T) val)
+{
+#ifdef __HLSL_VERSION
+	return spirv::floor(val);
+#else
+	return glm::floor(val);
+#endif
+	
+}
+
+// TODO: for clearer error messages, use concepts to ensure that input type is a square matrix
+// inverse not defined cause its implemented via hidden friend
+template<typename T, uint16_t N>
+inline matrix<T, N, N> inverse(NBL_CONST_REF_ARG(matrix<T, N, N>) m)
+{
+#ifdef __HLSL_VERSION
+	return spirv::matrixInverse(m);
+#else
+	return reinterpret_cast<matrix<T, N, N>&>(glm::inverse(reinterpret_cast<typename matrix<T, N, N>::Base const&>(m)));
+#endif
+}
+
+template<typename T, typename U>
+inline T lerp(NBL_CONST_REF_ARG(T) x, NBL_CONST_REF_ARG(T) y, NBL_CONST_REF_ARG(U) a)
+{
+	return cpp_compat_intrinsics_impl::lerp_helper<T, U>::lerp(x, y, a);
+}
+
+// transpose not defined cause its implemented via hidden friend
+template<typename T, uint16_t N, uint16_t M>
+inline matrix<T, M, N> transpose(NBL_CONST_REF_ARG(matrix<T, N, M>) m)
+{
+#ifdef __HLSL_VERSION
+	return spirv::transpose(m);
+#else
+	return reinterpret_cast<matrix<T, M, N>&>(glm::transpose(reinterpret_cast<typename matrix<T, N, M>::Base const&>(m)));
+#endif
+}
+
+template<typename T>
+inline T min(NBL_CONST_REF_ARG(T) a, NBL_CONST_REF_ARG(T) b)
+{
+#ifdef __HLSL_VERSION
+	min(a, b);
+#else
+	return glm::min(a, b);
+#endif
+}
+
+template<typename T>
+inline T max(NBL_CONST_REF_ARG(T) a, NBL_CONST_REF_ARG(T) b)
+{
+#ifdef __HLSL_VERSION
+	max(a, b);
+#else
+	return glm::max(a, b);
+#endif
+}
+
+template<typename FloatingPoint>
+inline FloatingPoint isnan(NBL_CONST_REF_ARG(FloatingPoint) val)
+{
+#ifdef __HLSL_VERSION
+	return spirv::isNan(val);
+#else
+	return std::isnan(val);
+#endif
+}
+
+template<typename FloatingPoint>
+inline FloatingPoint isinf(NBL_CONST_REF_ARG(FloatingPoint) val)
+{
+#ifdef __HLSL_VERSION
+	return spirv::isInf(val);
+#else
+	return std::isinf(val);
+#endif
+}
+
+template<typename  T>
+inline T exp2(NBL_CONST_REF_ARG(T) val)
+{
+#ifdef __HLSL_VERSION
+	return spirv::exp2(val);
+#else
+	return std::exp2(val);
+#endif
+}
+
+#define DEFINE_EXP2_SPECIALIZATION(TYPE)\
+template<>\
+inline TYPE exp2(NBL_CONST_REF_ARG(TYPE) val)\
+{\
+	return _static_cast<TYPE>(1ull << val);\
+}\
+
+DEFINE_EXP2_SPECIALIZATION(int16_t)
+DEFINE_EXP2_SPECIALIZATION(int32_t)
+DEFINE_EXP2_SPECIALIZATION(int64_t)
+DEFINE_EXP2_SPECIALIZATION(uint16_t)
+DEFINE_EXP2_SPECIALIZATION(uint32_t)
+DEFINE_EXP2_SPECIALIZATION(uint64_t)
+
+template<typename FloatingPoint>
+inline FloatingPoint rsqrt(FloatingPoint x)
+{
+	// TODO: https://stackoverflow.com/a/62239778
+#ifdef __HLSL_VERSION
+	return spirv::inverseSqrt(x);
+#else
+	return 1.0f / std::sqrt(x);
+#endif
+}
+
+}
+}
+
+#endif
\ No newline at end of file
diff --git a/include/nbl/builtin/hlsl/matrix_utils/matrix_traits.hlsl b/include/nbl/builtin/hlsl/matrix_utils/matrix_traits.hlsl
new file mode 100644
index 000000000..dd1019ef7
--- /dev/null
+++ b/include/nbl/builtin/hlsl/matrix_utils/matrix_traits.hlsl
@@ -0,0 +1,45 @@
+#ifndef _NBL_BUILTIN_HLSL_MATRIX_UTILS_MATRIX_TRAITS_INCLUDED_
+#define _NBL_BUILTIN_HLSL_MATRIX_UTILS_MATRIX_TRAITS_INCLUDED_
+
+#include <nbl/builtin/hlsl/cpp_compat.hlsl>
+
+namespace nbl
+{
+namespace hlsl
+{
+
+template<typename MatT>
+struct matrix_traits;
+
+// i choose to implement it this way because of this DXC bug: https://github.com/microsoft/DirectXShaderCompiler/issues/7007
+#define DEFINE_MATRIX_TRAITS_TEMPLATE_SPECIALIZATION(ROW_COUNT, COLUMN_COUNT) \
+template<typename T> \
+struct matrix_traits<matrix<T, ROW_COUNT, COLUMN_COUNT> > \
+{ \
+    using scalar_type = T; \
+    using row_type = vector<T, COLUMN_COUNT>; \
+    NBL_CONSTEXPR_STATIC_INLINE uint32_t RowCount = ROW_COUNT; \
+    NBL_CONSTEXPR_STATIC_INLINE uint32_t ColumnCount = COLUMN_COUNT; \
+    NBL_CONSTEXPR_STATIC_INLINE bool Square = RowCount == ColumnCount; \
+};
+
+DEFINE_MATRIX_TRAITS_TEMPLATE_SPECIALIZATION(2, 2)
+DEFINE_MATRIX_TRAITS_TEMPLATE_SPECIALIZATION(3, 3)
+DEFINE_MATRIX_TRAITS_TEMPLATE_SPECIALIZATION(4, 4)
+DEFINE_MATRIX_TRAITS_TEMPLATE_SPECIALIZATION(3, 4)
+
+// TODO: when this bug: https://github.com/microsoft/DirectXShaderCompiler/issues/7007 is fixed, uncomment and delete template specializations
+/*template<typename T, uint32_t N, uint32_t M>
+struct matrix_traits<matrix<T,N,M> >
+{
+    using scalar_type = T;
+    NBL_CONSTEXPR_STATIC_INLINE uint32_t RowCount = ROW_COUNT;
+    NBL_CONSTEXPR_STATIC_INLINE uint32_t ColumnCount = COLUMN_COUNT;
+    NBL_CONSTEXPR_STATIC_INLINE bool Square = RowCount == ColumnCount;
+};
+*/
+
+}
+}
+
+#endif
\ No newline at end of file
diff --git a/include/nbl/builtin/hlsl/spirv_intrinsics/core.hlsl b/include/nbl/builtin/hlsl/spirv_intrinsics/core.hlsl
index 5c7d73009..83208753d 100644
--- a/include/nbl/builtin/hlsl/spirv_intrinsics/core.hlsl
+++ b/include/nbl/builtin/hlsl/spirv_intrinsics/core.hlsl
@@ -7,7 +7,6 @@
 
 #ifdef __HLSL_VERSION // TODO: AnastZIuk fix public search paths so we don't choke
 #include "spirv/unified1/spirv.hpp"
-#include "spirv/unified1/GLSL.std.450.h"
 #endif
 
 #include "nbl/builtin/hlsl/type_traits.hlsl"
@@ -188,21 +187,6 @@ template<typename T, typename P>
 [[vk::ext_instruction(spv::OpStore)]]
 enable_if_t<is_spirv_type_v<P>,void> store(P pointer, T obj);
 
-//! Std 450 Extended set operations
-
-template<typename SquareMatrix>
-[[vk::ext_instruction(GLSLstd450MatrixInverse, "GLSL.std.450")]]
-SquareMatrix matrixInverse(NBL_CONST_REF_ARG(SquareMatrix) mat);
-
-[[vk::ext_instruction(GLSLstd450UnpackSnorm2x16, "GLSL.std.450")]]
-float32_t2 unpackSnorm2x16(uint32_t p);
-
-[[vk::ext_instruction(GLSLstd450UnpackSnorm4x8, "GLSL.std.450")]]
-float32_t4 unpackSnorm4x8(uint32_t p);
-
-[[vk::ext_instruction(GLSLstd450UnpackUnorm4x8, "GLSL.std.450")]]
-float32_t4 unpackUnorm4x8(uint32_t p);
-
 // Memory Semantics link here: https://registry.khronos.org/SPIR-V/specs/unified1/SPIRV.html#Memory_Semantics_-id-
 
 // https://registry.khronos.org/SPIR-V/specs/unified1/SPIRV.html#_memory_semantics_id
@@ -250,6 +234,18 @@ template<typename Integral>
 [[vk::ext_instruction( spv::OpBitReverse )]]
 enable_if_t<is_integral_v<Integral>, Integral> bitFieldReverse( Integral base );
 
+template<typename FloatingPoint>
+[[vk::ext_instruction( spv::OpIsNan )]]
+enable_if_t<is_floating_point_v<FloatingPoint>, bool> isNan(FloatingPoint val);
+
+template<typename FloatingPoint>
+[[vk::ext_instruction( spv::OpIsInf )]]
+enable_if_t<is_floating_point_v<FloatingPoint>, bool> isInf(FloatingPoint val);
+
+template<typename Matrix>
+[[vk::ext_instruction( spv::OpTranspose )]]
+Matrix transpose(NBL_CONST_REF_ARG(Matrix) mat);
+
 }
 
 #endif
diff --git a/include/nbl/builtin/hlsl/spirv_intrinsics/glsl.std.450.hlsl b/include/nbl/builtin/hlsl/spirv_intrinsics/glsl.std.450.hlsl
new file mode 100644
index 000000000..21d0bf233
--- /dev/null
+++ b/include/nbl/builtin/hlsl/spirv_intrinsics/glsl.std.450.hlsl
@@ -0,0 +1,87 @@
+#ifndef _NBL_BUILTIN_HLSL_SPIRV_INTRINSICS_GLSL_STD_450_INCLUDED_
+#define _NBL_BUILTIN_HLSL_SPIRV_INTRINSICS_GLSL_STD_450_INCLUDED_
+
+#ifdef __HLSL_VERSION
+#include <nbl/builtin/hlsl/cpp_compat.hlsl>
+#include <nbl/builtin/hlsl/concepts.hlsl>
+#include "spirv/unified1/GLSL.std.450.h"
+
+namespace nbl 
+{
+namespace hlsl
+{
+namespace spirv
+{
+
+// Find MSB and LSB restricted to 32-bit width component types https://registry.khronos.org/SPIR-V/specs/unified1/GLSL.std.450.html
+template<typename Integral32 NBL_FUNC_REQUIRES(is_same_v<Integral32, int32_t> || is_same_v<Integral32, uint32_t>)
+[[vk::ext_instruction(GLSLstd450::GLSLstd450FindILsb, "GLSL.std.450")]]
+Integral32 findILsb(Integral32 value);
+
+template<int N>
+[[vk::ext_instruction(GLSLstd450::GLSLstd450FindILsb, "GLSL.std.450")]]
+vector<int32_t, N> findILsb(vector<int32_t, N> value);
+
+template<int N>
+[[vk::ext_instruction(GLSLstd450::GLSLstd450FindILsb, "GLSL.std.450")]]
+vector<uint32_t, N> findILsb(vector<uint32_t, N> value);
+
+template<typename Int32_t NBL_FUNC_REQUIRES(is_same_v<Int32_t, int32_t>)
+[[vk::ext_instruction(GLSLstd450::GLSLstd450FindSMsb, "GLSL.std.450")]]
+int32_t findSMsb(Int32_t value);
+
+template<int N>
+[[vk::ext_instruction(GLSLstd450::GLSLstd450FindSMsb, "GLSL.std.450")]]
+vector<int32_t, N> findSMsb(vector<int32_t, N> value);
+
+template<typename Uint32_t NBL_FUNC_REQUIRES(is_same_v<Uint32_t, uint32_t>)
+[[vk::ext_instruction(GLSLstd450::GLSLstd450FindUMsb, "GLSL.std.450")]]
+int32_t findUMsb(Uint32_t value);
+
+template<int N>
+[[vk::ext_instruction(GLSLstd450::GLSLstd450FindUMsb, "GLSL.std.450")]]
+vector<uint32_t, N> findUMsb(vector<uint32_t, N> value);
+
+template<typename FloatingPoint>
+[[vk::ext_instruction(GLSLstd450::GLSLstd450Exp2, "GLSL.std.450")]]
+enable_if_t<is_floating_point<FloatingPoint>::value && !is_matrix_v<FloatingPoint>, FloatingPoint> exp2(FloatingPoint val);
+
+template<typename FloatingPoint>
+[[vk::ext_instruction(GLSLstd450::GLSLstd450InverseSqrt, "GLSL.std.450")]]
+enable_if_t<is_floating_point_v<FloatingPoint> && !is_matrix_v<FloatingPoint>, FloatingPoint> inverseSqrt(FloatingPoint val);
+ 
+template<typename FloatingPoint>
+[[vk::ext_instruction(GLSLstd450::GLSLstd450Floor, "GLSL.std.450")]]
+enable_if_t<is_floating_point_v<FloatingPoint> && !is_matrix_v<FloatingPoint>, FloatingPoint> floor(FloatingPoint val);
+
+template<typename FloatingPoint>
+[[vk::ext_instruction(GLSLstd450::GLSLstd450Cross, "GLSL.std.450")]]
+enable_if_t<is_floating_point_v<FloatingPoint>, vector<FloatingPoint, 3> > cross(in vector<FloatingPoint, 3> lhs, in vector<FloatingPoint, 3> rhs);
+
+template<typename FloatingPoint>
+[[vk::ext_instruction(GLSLstd450::GLSLstd450FMix, "GLSL.std.450")]]
+enable_if_t<is_floating_point_v<FloatingPoint> && !is_matrix_v<FloatingPoint>, FloatingPoint> fMix(FloatingPoint x, FloatingPoint y, FloatingPoint a);
+
+template<typename T, int N>
+[[vk::ext_instruction(GLSLstd450::GLSLstd450Determinant, "GLSL.std.450")]]
+T determinant(in matrix<T, N, N> mat);
+
+template<typename T, int N>
+[[vk::ext_instruction(GLSLstd450MatrixInverse, "GLSL.std.450")]]
+matrix<T, N, N> matrixInverse(in matrix<T, N, N> mat);
+
+[[vk::ext_instruction(GLSLstd450UnpackSnorm2x16, "GLSL.std.450")]]
+float32_t2 unpackSnorm2x16(uint32_t p);
+
+[[vk::ext_instruction(GLSLstd450UnpackSnorm4x8, "GLSL.std.450")]]
+float32_t4 unpackSnorm4x8(uint32_t p);
+
+[[vk::ext_instruction(GLSLstd450UnpackUnorm4x8, "GLSL.std.450")]]
+float32_t4 unpackUnorm4x8(uint32_t p);
+
+}
+}
+}
+
+#endif
+#endif
\ No newline at end of file
diff --git a/include/nbl/builtin/hlsl/type_traits.hlsl b/include/nbl/builtin/hlsl/type_traits.hlsl
index 58cedd81d..31587cd02 100644
--- a/include/nbl/builtin/hlsl/type_traits.hlsl
+++ b/include/nbl/builtin/hlsl/type_traits.hlsl
@@ -675,12 +675,49 @@ struct scalar_type<matrix<T,N,M>,false>
 template<typename T>
 using scalar_type_t = typename scalar_type<T>::type;
 
+template<uint16_t bytesize>
+struct integer_of_size
+{
+    using type = void;
+};
+
+#ifndef __HLSL_VERSION
+template<>
+struct integer_of_size<1>
+{
+    using type = int8_t;
+};
+#endif
+template<>
+struct integer_of_size<2>
+{
+    using type = int16_t;
+};
+template<>
+struct integer_of_size<4>
+{
+    using type = int32_t;
+};
+template<>
+struct integer_of_size<8>
+{
+    using type = int64_t;
+};
+template<uint16_t bytesize>
+using integer_of_size_t = typename integer_of_size<bytesize>::type;
 
 template<uint16_t bytesize>
 struct unsigned_integer_of_size
 {
     using type = void;
 };
+#ifndef __HLSL_VERSION
+template<>
+struct unsigned_integer_of_size<1>
+{
+    using type = uint8_t;
+};
+#endif
 template<>
 struct unsigned_integer_of_size<2>
 {
diff --git a/include/nbl/builtin/hlsl/vector_utils/vector_traits.hlsl b/include/nbl/builtin/hlsl/vector_utils/vector_traits.hlsl
new file mode 100644
index 000000000..a4e54e6b3
--- /dev/null
+++ b/include/nbl/builtin/hlsl/vector_utils/vector_traits.hlsl
@@ -0,0 +1,32 @@
+#ifndef _NBL_BUILTIN_HLSL_VECTOR_UTILS_VECTOR_TRAITS_INCLUDED_
+#define _NBL_BUILTIN_HLSL_VECTOR_UTILS_VECTOR_TRAITS_INCLUDED_
+#include <nbl/builtin/hlsl/cpp_compat/basic.h>
+
+namespace nbl
+{
+namespace hlsl
+{
+
+// The whole purpose of this file is to enable the creation of partial specializations of the vector_traits for 
+// custom types without introducing circular dependencies.
+
+template<typename VecT>
+struct vector_traits;
+
+// i choose to implement it this way because of this DXC bug: https://github.com/microsoft/DirectXShaderCom0piler/issues/7007
+#define DEFINE_VECTOR_TRAITS_TEMPLATE_SPECIALIZATION(DIMENSION) \
+template<typename T> \
+struct vector_traits<vector<T, DIMENSION> > \
+{ \
+    using scalar_type = T; \
+    NBL_CONSTEXPR_STATIC_INLINE uint32_t Dimension = DIMENSION; \
+};\
+
+DEFINE_VECTOR_TRAITS_TEMPLATE_SPECIALIZATION(2)
+DEFINE_VECTOR_TRAITS_TEMPLATE_SPECIALIZATION(3)
+DEFINE_VECTOR_TRAITS_TEMPLATE_SPECIALIZATION(4)
+
+}
+}
+
+#endif
\ No newline at end of file
diff --git a/include/nbl/core/util/bitflag.h b/include/nbl/core/util/bitflag.h
index 89f9f62ba..209879966 100644
--- a/include/nbl/core/util/bitflag.h
+++ b/include/nbl/core/util/bitflag.h
@@ -5,6 +5,7 @@
 #define _NBL_CORE_C_BITFLAG_H_INCLUDED_
 
 #include "BuildConfigOptions.h"
+#include <nbl/builtin/hlsl/cpp_compat/intrinsics.hlsl>
 
 namespace nbl::core
 {
@@ -50,5 +51,27 @@ struct blake3_hasher::update_impl<core::bitflag<T>,Dummy>
 
 template<typename T>
 concept Bitflag = std::is_same_v<bitflag<typename T::enum_t>, T>;
+
+}
+
+namespace nbl::hlsl::cpp_compat_intrinsics_impl
+{
+	template<typename ENUM_TYPE>
+	struct find_lsb_helper<core::bitflag<ENUM_TYPE>>
+	{
+		static int32_t findLSB(NBL_CONST_REF_ARG(core::bitflag<ENUM_TYPE>) val)
+		{
+			return find_lsb_helper<ENUM_TYPE>::findLSB(val.value);
+		}
+	};
+
+	template<typename ENUM_TYPE>
+	struct find_msb_helper<core::bitflag<ENUM_TYPE>>
+	{
+		static int32_t findMSB(NBL_CONST_REF_ARG(core::bitflag<ENUM_TYPE>) val)
+		{
+			return find_msb_helper<ENUM_TYPE>::findMSB(val.value);
+		}
+	};
 }
 #endif
\ No newline at end of file
diff --git a/include/nbl/video/utilities/ISimpleManagedSurface.h b/include/nbl/video/utilities/ISimpleManagedSurface.h
index c01a5e267..dbde2d5f5 100644
--- a/include/nbl/video/utilities/ISimpleManagedSurface.h
+++ b/include/nbl/video/utilities/ISimpleManagedSurface.h
@@ -1,7 +1,6 @@
 #ifndef _NBL_VIDEO_I_SIMPLE_MANAGED_SURFACE_H_INCLUDED_
 #define _NBL_VIDEO_I_SIMPLE_MANAGED_SURFACE_H_INCLUDED_
 
-
 #include "nbl/video/ISwapchain.h"
 #include "nbl/video/ILogicalDevice.h"
 
@@ -226,7 +225,7 @@ class NBL_API2 ISimpleManagedSurface : public core::IReferenceCounted
 					{
 						ISurface::SCapabilities caps = {};
 						m_surface->getSurfaceCapabilitiesForPhysicalDevice(physDev,caps);
-						m_maxImageCount = core::min(caps.maxImageCount,ISwapchain::MaxImages);
+						m_maxImageCount = std::min(static_cast<uint32_t>(caps.maxImageCount),ISwapchain::MaxImages);
 					}
 
 					for (uint8_t i=0u; i<m_maxImageCount; i++)
diff --git a/src/nbl/builtin/CMakeLists.txt b/src/nbl/builtin/CMakeLists.txt
index b70a5f119..9ed799827 100644
--- a/src/nbl/builtin/CMakeLists.txt
+++ b/src/nbl/builtin/CMakeLists.txt
@@ -210,6 +210,11 @@ LIST_BUILTIN_RESOURCE(NBL_RESOURCES_TO_EMBED "glsl/ext/DepthPyramidGenerator/vir
 
 # HLSL
 LIST_BUILTIN_RESOURCE(NBL_RESOURCES_TO_EMBED "hlsl/macros.h")
+
+# utility
+LIST_BUILTIN_RESOURCE(NBL_RESOURCES_TO_EMBED "hlsl/array_accessors.hlsl")
+LIST_BUILTIN_RESOURCE(NBL_RESOURCES_TO_EMBED "hlsl/vector_utils/vector_traits.hlsl")
+
 #spirv intrinsics
 LIST_BUILTIN_RESOURCE(NBL_RESOURCES_TO_EMBED "hlsl/spirv_intrinsics/core.hlsl")
 LIST_BUILTIN_RESOURCE(NBL_RESOURCES_TO_EMBED "hlsl/spirv_intrinsics/fragment_shader_pixel_interlock.hlsl")
@@ -219,10 +224,11 @@ LIST_BUILTIN_RESOURCE(NBL_RESOURCES_TO_EMBED "hlsl/spirv_intrinsics/subgroup_bal
 LIST_BUILTIN_RESOURCE(NBL_RESOURCES_TO_EMBED "hlsl/spirv_intrinsics/subgroup_basic.hlsl")
 LIST_BUILTIN_RESOURCE(NBL_RESOURCES_TO_EMBED "hlsl/spirv_intrinsics/subgroup_shuffle.hlsl")
 LIST_BUILTIN_RESOURCE(NBL_RESOURCES_TO_EMBED "hlsl/spirv_intrinsics/subgroup_vote.hlsl")
+LIST_BUILTIN_RESOURCE(NBL_RESOURCES_TO_EMBED "hlsl/spirv_intrinsics/glsl.std.450.hlsl")
 #C++ compatibility
 LIST_BUILTIN_RESOURCE(NBL_RESOURCES_TO_EMBED "hlsl/cpp_compat.hlsl")
 LIST_BUILTIN_RESOURCE(NBL_RESOURCES_TO_EMBED "hlsl/cpp_compat/basic.h")
-LIST_BUILTIN_RESOURCE(NBL_RESOURCES_TO_EMBED "hlsl/cpp_compat/intrinsics.h")
+LIST_BUILTIN_RESOURCE(NBL_RESOURCES_TO_EMBED "hlsl/cpp_compat/intrinsics.hlsl")
 LIST_BUILTIN_RESOURCE(NBL_RESOURCES_TO_EMBED "hlsl/cpp_compat/matrix.hlsl")
 LIST_BUILTIN_RESOURCE(NBL_RESOURCES_TO_EMBED "hlsl/cpp_compat/promote.hlsl")
 LIST_BUILTIN_RESOURCE(NBL_RESOURCES_TO_EMBED "hlsl/cpp_compat/vector.hlsl")
diff --git a/src/nbl/ext/TextRendering/TextRendering.cpp b/src/nbl/ext/TextRendering/TextRendering.cpp
index ea0a04e6c..a30ef8a2c 100644
--- a/src/nbl/ext/TextRendering/TextRendering.cpp
+++ b/src/nbl/ext/TextRendering/TextRendering.cpp
@@ -47,7 +47,7 @@ void TextRenderer::generateShapeMSDF(
 
 	msdfgen::Bitmap<float, 4> msdfMap(msdfExtents.x, msdfExtents.y);
 	
-	float32_t pxRange = msdfPixelRange / (min(scale.x, scale.y));
+	float32_t pxRange = msdfPixelRange / (hlsl::min(scale.x, scale.y));
 	msdfgen::generateMTSDF(msdfMap, glyph, pxRange, { scale.x, scale.y }, { translate.x, translate.y });
 
 	for (int y = 0; y < msdfExtents.x; ++y)
diff --git a/src/nbl/video/CVulkanGraphicsPipeline.h b/src/nbl/video/CVulkanGraphicsPipeline.h
index 985740df0..c4c58c603 100644
--- a/src/nbl/video/CVulkanGraphicsPipeline.h
+++ b/src/nbl/video/CVulkanGraphicsPipeline.h
@@ -19,7 +19,7 @@ class CVulkanGraphicsPipeline final : public IGPUGraphicsPipeline
 			for (const auto& info : params.shaders)
 			if (info.shader)
 			{
-				const auto stageIx = hlsl::findLSB(info.shader->getStage());
+                const auto stageIx = hlsl::findLSB(info.shader->getStage());
 				m_shaders[stageIx] = core::smart_refctd_ptr<const CVulkanShader>(static_cast<const CVulkanShader*>(info.shader));
 			}
         }