diff --git a/source/blender/gpu/GPU_shader_shared_utils.hh b/source/blender/gpu/GPU_shader_shared_utils.hh
index 5fe801e44e1..244d877c57e 100644
--- a/source/blender/gpu/GPU_shader_shared_utils.hh
+++ b/source/blender/gpu/GPU_shader_shared_utils.hh
@@ -28,7 +28,9 @@
  * NOTE: You can use bool type using bool32_t a int boolean type matching the GLSL type.
  */
 
-#ifdef GPU_SHADER
+#ifdef GLSL_CPP_STUBS
+/* Do nothing. */
+#elif defined(GPU_SHADER)
 /* Silence macros when compiling for shaders. */
 #  define BLI_STATIC_ASSERT(cond, msg)
 #  define BLI_STATIC_ASSERT_ALIGN(type_, align_)
diff --git a/source/blender/gpu/shaders/gpu_glsl_cpp_stubs.hh b/source/blender/gpu/shaders/gpu_glsl_cpp_stubs.hh
new file mode 100644
index 00000000000..7be05bcaf47
--- /dev/null
+++ b/source/blender/gpu/shaders/gpu_glsl_cpp_stubs.hh
@@ -0,0 +1,787 @@
+/* SPDX-FileCopyrightText: 2024 Blender Authors
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later */
+
+/**
+ * GLSL to C++ stubs.
+ *
+ * The goal of this header is to make the GLSL source file compile using a modern C++ compiler.
+ * This allows for linting and IDE functionalities to work.
+ *
+ * This file can be included inside any GLSL file to make the GLSL syntax to work. Then your IDE
+ * must to be configured to associate .glsl files to C++ so that the C++ linter does the analysis.
+ *
+ * This is why the implementation of each function is not needed. However, we make sure that type
+ * casting is always explicit. This is because implicit casts are not always supported on all
+ * implementations.
+ *
+ * Float types are set to double to accept float literals without trailing f and avoid casting
+ * issues.
+ *
+ * Some of the features of GLSL are omitted by design. They are either:
+ * - not needed (e.g. per component matrix multiplication)
+ * - against our code-style (e.g. stpq swizzle)
+ * - unsupported by our Metal Shading Language layer (e.g. mixed vector-scalar matrix constructor).
+ *
+ * IMPORTANT: Please ask the module team if you need some feature that are not listed in this file.
+ */
+
+#pragma once
+
+#include <type_traits>
+
+/* -------------------------------------------------------------------- */
+/** \name Vector Types
+ * \{ */
+
+template<typename T, int Sz> struct VecBase {};
+
+template<typename T, int Sz> struct VecOp {
+  using VecT = VecBase<T, Sz>;
+
+  T &operator[](int) {}
+
+  VecT operator+() const {}
+  VecT operator-() const {}
+
+  VecT operator+(VecT) const {}
+  VecT operator-(VecT) const {}
+  VecT operator/(VecT) const {}
+  VecT operator*(VecT) const {}
+
+  VecT operator+=(VecT) const {}
+  VecT operator-=(VecT) const {}
+  VecT operator/=(VecT) const {}
+  VecT operator*=(VecT) const {}
+
+  VecT operator+(T) const {}
+  VecT operator-(T) const {}
+  VecT operator/(T) const {}
+  VecT operator*(T) const {}
+
+  VecT operator+=(T) const {}
+  VecT operator-=(T) const {}
+  VecT operator/=(T) const {}
+  VecT operator*=(T) const {}
+
+  friend VecT operator+(T, VecT) {}
+  friend VecT operator-(T, VecT) {}
+  friend VecT operator/(T, VecT) {}
+  friend VecT operator*(T, VecT) {}
+
+#define INT_OP \
+  template<typename U = T, typename std::enable_if_t<std::is_integral_v<U>> * = nullptr>
+
+  INT_OP VecT operator%(VecT) const {}
+  INT_OP VecT operator&(VecT) const {}
+  INT_OP VecT operator|(VecT) const {}
+  INT_OP VecT operator^(VecT) const {}
+
+  INT_OP VecT operator%=(VecT) const {}
+  INT_OP VecT operator&=(VecT) const {}
+  INT_OP VecT operator|=(VecT) const {}
+  INT_OP VecT operator^=(VecT) const {}
+
+  INT_OP VecT operator%(T) const {}
+  INT_OP VecT operator&(T) const {}
+  INT_OP VecT operator|(T) const {}
+  INT_OP VecT operator^(T) const {}
+
+  INT_OP VecT operator%=(T) const {}
+  INT_OP VecT operator&=(T) const {}
+  INT_OP VecT operator|=(T) const {}
+  INT_OP VecT operator^=(T) const {}
+
+  INT_OP friend VecT operator%(T, VecT) {}
+  INT_OP friend VecT operator&(T, VecT) {}
+  INT_OP friend VecT operator|(T, VecT) {}
+  INT_OP friend VecT operator^(T, VecT) {}
+
+#undef INT_OP
+};
+
+template<typename T> struct VecSwizzle2 {
+  static VecBase<T, 2> &xx, &xy, &yx, &yy;
+  static VecBase<T, 3> &xxx, &xxy, &xyx, &xyy, &yxx, &yxy, &yyx, &yyy;
+  static VecBase<T, 4> &xxxx, &xxxy, &xxyx, &xxyy, &xyxx, &xyxy, &xyyx, &xyyy, &yxxx, &yxxy, &yxyx,
+      &yxyy, &yyxx, &yyxy, &yyyx, &yyyy;
+};
+
+template<typename T> struct ColSwizzle2 {
+  static VecBase<T, 2> &rr, &rg, &gr, &gg;
+  static VecBase<T, 3> &rrr, &rrg, &rgr, &rgg, &grr, &grg, &ggr, &ggg;
+  static VecBase<T, 4> &rrrr, &rrrg, &rrgr, &rrgg, &rgrr, &rgrg, &rggr, &rggg, &grrr, &grrg, &grgr,
+      &grgg, &ggrr, &ggrg, &gggr, &gggg;
+};
+
+template<typename T> struct VecSwizzle3 : VecSwizzle2<T> {
+  static VecBase<T, 2> &xz, &yz, &zx, &zy, &zz, &zw;
+  static VecBase<T, 3> &xxz, &xyz, &xzx, &xzy, &xzz, &yxz, &yyz, &yzx, &yzy, &yzz, &zxx, &zxy,
+      &zxz, &zyx, &zyy, &zyz, &zzx, &zzy, &zzz;
+  static VecBase<T, 4> &xxxz, &xxyz, &xxzx, &xxzy, &xxzz, &xyxz, &xyyz, &xyzx, &xyzy, &xyzz, &xzxx,
+      &xzxy, &xzxz, &xzyx, &xzyy, &xzyz, &xzzx, &xzzy, &xzzz, &yxxz, &yxyz, &yxzx, &yxzy, &yxzz,
+      &yyxz, &yyyz, &yyzx, &yyzy, &yyzz, &yzxx, &yzxy, &yzxz, &yzyx, &yzyy, &yzyz, &yzzx, &yzzy,
+      &yzzz, &zxxx, &zxxy, &zxxz, &zxyx, &zxyy, &zxyz, &zxzx, &zxzy, &zxzz, &zyxx, &zyxy, &zyxz,
+      &zyyx, &zyyy, &zyyz, &zyzx, &zyzy, &zyzz, &zzxx, &zzxy, &zzxz, &zzyx, &zzyy, &zzyz, &zzzx,
+      &zzzy, &zzzz;
+};
+
+template<typename T> struct ColSwizzle3 : ColSwizzle2<T> {
+  static VecBase<T, 2> &rb, &gb, &br, &bg, &bb, &bw;
+  static VecBase<T, 3> &rrb, &rgb, &rbr, &rbg, &rbb, &grb, &ggb, &gbr, &gbg, &gbb, &brr, &brg,
+      &brb, &bgr, &bgg, &bgb, &bbr, &bbg, &bbb;
+  static VecBase<T, 4> &rrrb, &rrgb, &rrbr, &rrbg, &rrbb, &rgrb, &rggb, &rgbr, &rgbg, &rgbb, &rbrr,
+      &rbrg, &rbrb, &rbgr, &rbgg, &rbgb, &rbbr, &rbbg, &rbbb, &grrb, &grgb, &grbr, &grbg, &grbb,
+      &ggrb, &gggb, &ggbr, &ggbg, &ggbb, &gbrr, &gbrg, &gbrb, &gbgr, &gbgg, &gbgb, &gbbr, &gbbg,
+      &gbbb, &brrr, &brrg, &brrb, &brgr, &brgg, &brgb, &brbr, &brbg, &brbb, &bgrr, &bgrg, &bgrb,
+      &bggr, &bggg, &bggb, &bgbr, &bgbg, &bgbb, &bbrr, &bbrg, &bbrb, &bbgr, &bbgg, &bbgb, &bbbr,
+      &bbbg, &bbbb;
+};
+
+template<typename T> struct VecSwizzle4 : VecSwizzle3<T> {
+  static VecBase<T, 2> &xw, &yw, &wx, &wy, &wz, &ww;
+  static VecBase<T, 3> &xxw, &xyw, &xzw, &xwx, &xwy, &xwz, &xww, &yxw, &yyw, &yzw, &ywx, &ywy,
+      &ywz, &yww, &zxw, &zyw, &zzw, &zwx, &zwy, &zwz, &zww, &wxx, &wxy, &wxz, &wxw, &wyx, &wyy,
+      &wyz, &wyw, &wzx, &wzy, &wzz, &wzw, &wwx, &wwy, &wwz, &www;
+  static VecBase<T, 4> &xxxw, &xxyw, &xxzw, &xxwx, &xxwy, &xxwz, &xxww, &xyxw, &xyyw, &xyzw, &xywx,
+      &xywy, &xywz, &xyww, &xzxw, &xzyw, &xzzw, &xzwx, &xzwy, &xzwz, &xzww, &xwxx, &xwxy, &xwxz,
+      &xwxw, &xwyx, &xwyy, &xwyz, &xwyw, &xwzx, &xwzy, &xwzz, &xwzw, &xwwx, &xwwy, &xwwz, &xwww,
+      &yxxw, &yxyw, &yxzw, &yxwx, &yxwy, &yxwz, &yxww, &yyxw, &yyyw, &yyzw, &yywx, &yywy, &yywz,
+      &yyww, &yzxw, &yzyw, &yzzw, &yzwx, &yzwy, &yzwz, &yzww, &ywxx, &ywxy, &ywxz, &ywxw, &ywyx,
+      &ywyy, &ywyz, &ywyw, &ywzx, &ywzy, &ywzz, &ywzw, &ywwx, &ywwy, &ywwz, &ywww, &zxxw, &zxyw,
+      &zxzw, &zxwx, &zxwy, &zxwz, &zxww, &zyxw, &zyyw, &zyzw, &zywx, &zywy, &zywz, &zyww, &zzxw,
+      &zzyw, &zzzw, &zzwx, &zzwy, &zzwz, &zzww, &zwxx, &zwxy, &zwxz, &zwxw, &zwyx, &zwyy, &zwyz,
+      &zwyw, &zwzx, &zwzy, &zwzz, &zwzw, &zwwx, &zwwy, &zwwz, &zwww, &wxxx, &wxxy, &wxxz, &wxxw,
+      &wxyx, &wxyy, &wxyz, &wxyw, &wxzx, &wxzy, &wxzz, &wxzw, &wxwx, &wxwy, &wxwz, &wxww, &wyxx,
+      &wyxy, &wyxz, &wyxw, &wyyx, &wyyy, &wyyz, &wyyw, &wyzx, &wyzy, &wyzz, &wyzw, &wywx, &wywy,
+      &wywz, &wyww, &wzxx, &wzxy, &wzxz, &wzxw, &wzyx, &wzyy, &wzyz, &wzyw, &wzzx, &wzzy, &wzzz,
+      &wzzw, &wzwx, &wzwy, &wzwz, &wzww, &wwxx, &wwxy, &wwxz, &wwxw, &wwyx, &wwyy, &wwyz, &wwyw,
+      &wwzx, &wwzy, &wwzz, &wwzw, &wwwx, &wwwy, &wwwz, &wwww;
+};
+
+template<typename T> struct ColSwizzle4 : ColSwizzle3<T> {
+  static VecBase<T, 2> &ra, &ga, &ar, &ag, &ab, &aa;
+  static VecBase<T, 3> &rra, &rga, &rba, &rar, &rag, &rab, &raa, &gra, &gga, &gba, &gar, &gag,
+      &gab, &gaa, &bra, &bga, &bba, &bar, &bag, &bab, &baa, &arr, &arg, &arb, &ara, &agr, &agg,
+      &agb, &aga, &abr, &abg, &abb, &aba, &aar, &aag, &aab, &aaa;
+  static VecBase<T, 4> &rrra, &rrga, &rrba, &rrar, &rrag, &rrab, &rraa, &rgra, &rgga, &rgba, &rgar,
+      &rgag, &rgab, &rgaa, &rbra, &rbga, &rbba, &rbar, &rbag, &rbab, &rbaa, &rarr, &rarg, &rarb,
+      &rara, &ragr, &ragg, &ragb, &raga, &rabr, &rabg, &rabb, &raba, &raar, &raag, &raab, &raaa,
+      &grra, &grga, &grba, &grar, &grag, &grab, &graa, &ggra, &ggga, &ggba, &ggar, &ggag, &ggab,
+      &ggaa, &gbra, &gbga, &gbba, &gbar, &gbag, &gbab, &gbaa, &garr, &garg, &garb, &gara, &gagr,
+      &gagg, &gagb, &gaga, &gabr, &gabg, &gabb, &gaba, &gaar, &gaag, &gaab, &gaaa, &brra, &brga,
+      &brba, &brar, &brag, &brab, &braa, &bgra, &bgga, &bgba, &bgar, &bgag, &bgab, &bgaa, &bbra,
+      &bbga, &bbba, &bbar, &bbag, &bbab, &bbaa, &barr, &barg, &barb, &bara, &bagr, &bagg, &bagb,
+      &baga, &babr, &babg, &babb, &baba, &baar, &baag, &baab, &baaa, &arrr, &arrg, &arrb, &arra,
+      &argr, &argg, &argb, &arga, &arbr, &arbg, &arbb, &arba, &arar, &arag, &arab, &araa, &agrr,
+      &agrg, &agrb, &agra, &aggr, &aggg, &aggb, &agga, &agbr, &agbg, &agbb, &agba, &agar, &agag,
+      &agab, &agaa, &abrr, &abrg, &abrb, &abra, &abgr, &abgg, &abgb, &abga, &abbr, &abbg, &abbb,
+      &abba, &abar, &abag, &abab, &abaa, &aarr, &aarg, &aarb, &aara, &aagr, &aagg, &aagb, &aaga,
+      &aabr, &aabg, &aabb, &aaba, &aaar, &aaag, &aaab, &aaaa;
+};
+
+template<typename T> struct VecBase<T, 2> : VecOp<T, 2>, VecSwizzle2<T>, ColSwizzle2<T> {
+  T x, y;
+  T r, g;
+
+  VecBase() = default;
+  template<typename U> explicit VecBase(VecBase<U, 2>) {}
+  explicit VecBase(T) {}
+  explicit VecBase(T, T) {}
+};
+
+template<typename T> struct VecBase<T, 3> : VecOp<T, 3>, VecSwizzle3<T>, ColSwizzle3<T> {
+  T x, y, z;
+  T r, g, b;
+
+  VecBase() = default;
+  template<typename U> explicit VecBase(VecBase<U, 3>) {}
+  explicit VecBase(T) {}
+  explicit VecBase(T, T, T) {}
+  explicit VecBase(VecBase<T, 2>, T) {}
+  explicit VecBase(T, VecBase<T, 2>) {}
+};
+
+template<typename T> struct VecBase<T, 4> : VecOp<T, 4>, VecSwizzle4<T>, ColSwizzle4<T> {
+  T x, y, z, w;
+  T r, g, b, a;
+
+  VecBase() = default;
+  template<typename U> explicit VecBase(VecBase<U, 4>) {}
+  explicit VecBase(T) {}
+  explicit VecBase(T, T, T, T) {}
+  explicit VecBase(VecBase<T, 2>, T, T) {}
+  explicit VecBase(T, VecBase<T, 2>, T) {}
+  explicit VecBase(T, T, VecBase<T, 2>) {}
+  explicit VecBase(VecBase<T, 2>, VecBase<T, 2>) {}
+  explicit VecBase(VecBase<T, 3>, T) {}
+  explicit VecBase(T, VecBase<T, 3>) {}
+};
+
+/* Boolean vectors do not have operators and are not convertible from other types. */
+
+template<> struct VecBase<bool, 2> : VecSwizzle2<bool> {
+  bool x, y;
+
+  VecBase() = default;
+  explicit VecBase(bool) {}
+  explicit VecBase(bool, bool) {}
+};
+
+template<> struct VecBase<bool, 3> : VecSwizzle3<bool> {
+  bool x, y, z;
+
+  VecBase() = default;
+  explicit VecBase(bool) {}
+  explicit VecBase(bool, bool, bool) {}
+  explicit VecBase(VecBase<bool, 2>, bool) {}
+  explicit VecBase(bool, VecBase<bool, 2>) {}
+};
+
+template<> struct VecBase<bool, 4> : VecSwizzle4<bool> {
+  bool x, y, z, w;
+
+  VecBase() = default;
+  explicit VecBase(bool) {}
+  explicit VecBase(bool, bool, bool, bool) {}
+  explicit VecBase(VecBase<bool, 2>, bool, bool) {}
+  explicit VecBase(bool, VecBase<bool, 2>, bool) {}
+  explicit VecBase(bool, bool, VecBase<bool, 2>) {}
+  explicit VecBase(VecBase<bool, 2>, VecBase<bool, 2>) {}
+  explicit VecBase(VecBase<bool, 3>, bool) {}
+  explicit VecBase(bool, VecBase<bool, 3>) {}
+};
+
+using uint = unsigned int;
+
+using float2 = VecBase<double, 2>;
+using float3 = VecBase<double, 3>;
+using float4 = VecBase<double, 4>;
+
+using uint2 = VecBase<uint, 2>;
+using uint3 = VecBase<uint, 3>;
+using uint4 = VecBase<uint, 4>;
+
+using int2 = VecBase<int, 2>;
+using int3 = VecBase<int, 3>;
+using int4 = VecBase<int, 4>;
+
+using bool2 = VecBase<bool, 2>;
+using bool3 = VecBase<bool, 3>;
+using bool4 = VecBase<bool, 4>;
+
+using vec2 = float2;
+using vec3 = float3;
+using vec4 = float4;
+
+using ivec2 = int2;
+using ivec3 = int3;
+using ivec4 = int4;
+
+using uvec2 = uint2;
+using uvec3 = uint3;
+using uvec4 = uint4;
+
+using bvec2 = bool2;
+using bvec3 = bool3;
+using bvec4 = bool4;
+
+/** \} */
+
+/* -------------------------------------------------------------------- */
+/** \name Matrix Types
+ * \{ */
+
+template<int C, int R> struct MatBase {};
+
+template<int C, int R> struct MatOp {
+  using MatT = MatBase<C, R>;
+  using ColT = VecBase<double, R>;
+  using RowT = VecBase<double, C>;
+
+  ColT &operator[](int) {}
+
+  MatT operator*(MatT) const {}
+
+  friend ColT operator*(RowT, MatT) {}
+  friend RowT operator*(MatT, ColT) {}
+};
+
+template<int R> struct MatBase<2, R> : MatOp<2, R> {
+  using T = double;
+  using ColT = VecBase<double, R>;
+  ColT x, y;
+
+  MatBase() = default;
+  explicit MatBase(T) {}
+  explicit MatBase(T, T, T, T) {}
+  explicit MatBase(ColT, ColT) {}
+  template<int OtherC, int OtherR> explicit MatBase(const MatBase<OtherC, OtherR> &) {}
+};
+
+template<int R> struct MatBase<3, R> : MatOp<3, R> {
+  using T = double;
+  using ColT = VecBase<double, R>;
+  ColT x, y, z;
+
+  MatBase() = default;
+  explicit MatBase(T) {}
+  explicit MatBase(T, T, T, T, T, T, T, T, T) {}
+  explicit MatBase(ColT, ColT, ColT) {}
+  template<int OtherC, int OtherR> explicit MatBase(const MatBase<OtherC, OtherR> &) {}
+};
+
+template<int R> struct MatBase<4, R> : MatOp<4, R> {
+  using T = double;
+  using ColT = VecBase<double, R>;
+  ColT x, y, z, w;
+
+  MatBase() = default;
+  explicit MatBase(T) {}
+  explicit MatBase(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) {}
+  explicit MatBase(ColT, ColT, ColT, ColT) {}
+  template<int OtherC, int OtherR> explicit MatBase(const MatBase<OtherC, OtherR> &) {}
+};
+
+using float2x2 = MatBase<2, 2>;
+using float2x3 = MatBase<2, 3>;
+using float2x4 = MatBase<2, 4>;
+using float3x2 = MatBase<3, 2>;
+using float3x3 = MatBase<3, 3>;
+using float3x4 = MatBase<3, 4>;
+using float4x2 = MatBase<4, 2>;
+using float4x3 = MatBase<4, 3>;
+using float4x4 = MatBase<4, 4>;
+
+using mat2x2 = float2x2;
+using mat2x3 = float2x3;
+using mat2x4 = float2x4;
+using mat3x2 = float3x2;
+using mat3x3 = float3x3;
+using mat3x4 = float3x4;
+using mat4x2 = float4x2;
+using mat4x3 = float4x3;
+using mat4x4 = float4x4;
+
+using mat2 = float2x2;
+using mat3 = float3x3;
+using mat4 = float4x4;
+
+/** \} */
+
+/* -------------------------------------------------------------------- */
+/** \name Sampler Types
+ * \{ */
+
+template<typename T, int Dimensions, bool Cube = false, bool Array = false> struct SamplerBase {
+  static constexpr int coord_dim = Dimensions + int(Cube) + int(Array);
+  static constexpr int deriv_dim = Dimensions + int(Cube);
+  static constexpr int extent_dim = Dimensions + int(Array);
+
+  using int_coord_type = VecBase<int, coord_dim>;
+  using flt_coord_type = VecBase<double, coord_dim>;
+  using derivative_type = VecBase<double, deriv_dim>;
+  using data_vec_type = VecBase<T, 4>;
+  using size_vec_type = VecBase<int, extent_dim>;
+};
+
+#define TEX_TEMPLATE \
+  template<typename T, \
+           typename IntCoord = typename T::int_coord_type, \
+           typename FltCoord = typename T::flt_coord_type, \
+           typename DerivVec = typename T::derivative_type, \
+           typename DataVec = typename T::data_vec_type, \
+           typename SizeVec = typename T::size_vec_type>
+
+TEX_TEMPLATE SizeVec textureSize(T, int) {}
+TEX_TEMPLATE DataVec texelFetch(T, IntCoord, int) {}
+TEX_TEMPLATE DataVec texelFetchOffset(T, IntCoord, int, IntCoord) {}
+TEX_TEMPLATE DataVec texture(T, FltCoord, double bias = 0.0) {}
+TEX_TEMPLATE DataVec textureGather(T, FltCoord) {}
+TEX_TEMPLATE DataVec textureGrad(T, FltCoord, DerivVec, DerivVec) {}
+TEX_TEMPLATE DataVec textureLod(T, FltCoord, double) {}
+
+#undef TEX_TEMPLATE
+
+using sampler1D = SamplerBase<double, 1>;
+using sampler2D = SamplerBase<double, 2>;
+using sampler3D = SamplerBase<double, 3>;
+using isampler1D = SamplerBase<int, 1>;
+using isampler2D = SamplerBase<int, 2>;
+using isampler3D = SamplerBase<int, 3>;
+using usampler1D = SamplerBase<uint, 1>;
+using usampler2D = SamplerBase<uint, 2>;
+using usampler3D = SamplerBase<uint, 3>;
+
+using sampler1DArray = SamplerBase<double, 1, false, true>;
+using sampler2DArray = SamplerBase<double, 2, false, true>;
+using isampler1DArray = SamplerBase<int, 1, false, true>;
+using isampler2DArray = SamplerBase<int, 2, false, true>;
+using usampler1DArray = SamplerBase<uint, 1, false, true>;
+using usampler2DArray = SamplerBase<uint, 2, false, true>;
+
+using samplerCube = SamplerBase<double, 2, true>;
+using isamplerCube = SamplerBase<int, 2, true>;
+using usamplerCube = SamplerBase<uint, 2, true>;
+
+using samplerCubeArray = SamplerBase<double, 2, true, true>;
+using isamplerCubeArray = SamplerBase<int, 2, true, true>;
+using usamplerCubeArray = SamplerBase<uint, 2, true, true>;
+
+/** \} */
+
+/* -------------------------------------------------------------------- */
+/** \name Image Types
+ * \{ */
+
+template<typename T, int Dimensions, bool Array = false> struct ImageBase {
+  static constexpr int coord_dim = Dimensions + int(Array);
+
+  using int_coord_type = VecBase<int, coord_dim>;
+  using data_vec_type = VecBase<T, 4>;
+  using size_vec_type = VecBase<int, coord_dim>;
+};
+
+#define IMG_TEMPLATE \
+  template<typename T, \
+           typename IntCoord = typename T::int_coord_type, \
+           typename DataVec = typename T::data_vec_type, \
+           typename SizeVec = typename T::size_vec_type>
+
+IMG_TEMPLATE SizeVec imageSize(const T &) {}
+IMG_TEMPLATE DataVec imageLoad(const T &, IntCoord) {}
+IMG_TEMPLATE void imageStore(T &, IntCoord, DataVec) {}
+IMG_TEMPLATE void imageFence(T &) {}
+/* Cannot write to a read only image. */
+IMG_TEMPLATE void imageStore(const T &, IntCoord, DataVec) = delete;
+IMG_TEMPLATE void imageFence(const T &) = delete;
+
+#define imageLoadFast imageLoad
+#define imageStoreFast imageStore
+
+IMG_TEMPLATE uint imageAtomicAdd(T &, IntCoord, uint) {}
+IMG_TEMPLATE uint imageAtomicMin(T &, IntCoord, uint) {}
+IMG_TEMPLATE uint imageAtomicMax(T &, IntCoord, uint) {}
+IMG_TEMPLATE uint imageAtomicAnd(T &, IntCoord, uint) {}
+IMG_TEMPLATE uint imageAtomicXor(T &, IntCoord, uint) {}
+IMG_TEMPLATE uint imageAtomicExchange(T &, IntCoord, uint) {}
+IMG_TEMPLATE uint imageAtomicCompSwap(T &, IntCoord, uint, uint) {}
+/* Cannot write to a read only image. */
+IMG_TEMPLATE uint imageAtomicAdd(const T &, IntCoord, uint) = delete;
+IMG_TEMPLATE uint imageAtomicMin(const T &, IntCoord, uint) = delete;
+IMG_TEMPLATE uint imageAtomicMax(const T &, IntCoord, uint) = delete;
+IMG_TEMPLATE uint imageAtomicAnd(const T &, IntCoord, uint) = delete;
+IMG_TEMPLATE uint imageAtomicXor(const T &, IntCoord, uint) = delete;
+IMG_TEMPLATE uint imageAtomicExchange(const T &, IntCoord, uint) = delete;
+IMG_TEMPLATE uint imageAtomicCompSwap(const T &, IntCoord, uint, uint) = delete;
+
+#undef IMG_TEMPLATE
+
+using image1D = ImageBase<double, 1>;
+using image2D = ImageBase<double, 2>;
+using image3D = ImageBase<double, 3>;
+using iimage1D = ImageBase<int, 1>;
+using iimage2D = ImageBase<int, 2>;
+using iimage3D = ImageBase<int, 3>;
+using uimage1D = ImageBase<uint, 1>;
+using uimage2D = ImageBase<uint, 2>;
+using uimage3D = ImageBase<uint, 3>;
+
+using image1DArray = ImageBase<double, 1, true>;
+using image2DArray = ImageBase<double, 2, true>;
+using iimage1DArray = ImageBase<int, 1, true>;
+using iimage2DArray = ImageBase<int, 2, true>;
+using uimage1DArray = ImageBase<uint, 1, true>;
+using uimage2DArray = ImageBase<uint, 2, true>;
+
+/* Forbid Cube and cube arrays. Bind them as 3D textures instead. */
+
+/** \} */
+
+/* -------------------------------------------------------------------- */
+/** \name Builtin Functions
+ * \{ */
+
+/* Some compilers complain about lack of return values. Keep it short. */
+#define RET \
+  { \
+    return {}; \
+  }
+
+template<typename T, int D> VecBase<bool, D> greaterThan(VecBase<T, D>, VecBase<T, D>) RET;
+template<typename T, int D> VecBase<bool, D> lessThan(VecBase<T, D>, VecBase<T, D>) RET;
+template<typename T, int D> VecBase<bool, D> lessThanEqual(VecBase<T, D>, VecBase<T, D>) RET;
+template<typename T, int D> VecBase<bool, D> greaterThanEqual(VecBase<T, D>, VecBase<T, D>) RET;
+template<typename T, int D> VecBase<bool, D> equal(VecBase<T, D>, VecBase<T, D>) RET;
+template<typename T, int D> VecBase<bool, D> notEqual(VecBase<T, D>, VecBase<T, D>) RET;
+template<int D> bool any(VecBase<bool, D>) RET;
+template<int D> bool all(VecBase<bool, D>) RET;
+/* `not` is a C++ keyword that aliases the `!` operator. Simply overload it. */
+template<int D> VecBase<bool, D> operator!(VecBase<bool, D>) RET;
+
+template<int D> VecBase<int, D> bitCount(VecBase<int, D>) RET;
+template<int D> VecBase<int, D> bitCount(VecBase<uint, D>) RET;
+template<int D> VecBase<int, D> bitfieldExtract(VecBase<int, D>, int, int) RET;
+template<int D> VecBase<int, D> bitfieldExtract(VecBase<uint, D>, int, int) RET;
+template<int D> VecBase<int, D> bitfieldInsert(VecBase<int, D>, VecBase<int, D>, int, int) RET;
+template<int D> VecBase<int, D> bitfieldInsert(VecBase<uint, D>, VecBase<uint, D>, int, int) RET;
+template<int D> VecBase<int, D> bitfieldReverse(VecBase<int, D>) RET;
+template<int D> VecBase<int, D> bitfieldReverse(VecBase<uint, D>) RET;
+int bitCount(int) RET;
+int bitCount(uint) RET;
+int bitfieldExtract(int) RET;
+int bitfieldExtract(uint) RET;
+int bitfieldInsert(int) RET;
+int bitfieldInsert(uint) RET;
+int bitfieldReverse(int) RET;
+int bitfieldReverse(uint) RET;
+
+template<int D> VecBase<int, D> findLSB(VecBase<int, D>) RET;
+template<int D> VecBase<int, D> findLSB(VecBase<uint, D>) RET;
+template<int D> VecBase<int, D> findMSB(VecBase<int, D>) RET;
+template<int D> VecBase<int, D> findMSB(VecBase<uint, D>) RET;
+int findMSB(int) RET;
+int findMSB(uint) RET;
+
+/* Math Functions. */
+template<typename T> T abs(T) RET;
+template<typename T> T clamp(T, T, T) RET;
+template<typename T> T max(T, T) RET;
+template<typename T> T min(T, T) RET;
+template<typename T> T sign(T) RET;
+template<typename T, typename U> T clamp(T, U, U) RET;
+template<typename T, typename U> T max(T, U) RET;
+template<typename T, typename U> T min(T, U) RET;
+/* TODO(fclem): These should be restricted to floats. */
+template<typename T> T ceil(T) RET;
+template<typename T> T exp(T) RET;
+template<typename T> T exp2(T) RET;
+template<typename T> T floor(T) RET;
+template<typename T> T fma(T, T, T) RET;
+template<typename T> T fract(T) RET;
+template<typename T> T frexp(T, T) RET;
+template<typename T> T inversesqrt(T) RET;
+template<typename T> T isinf(T) RET;
+template<typename T> T isnan(T) RET;
+template<typename T> T log(T) RET;
+template<typename T> T log2(T) RET;
+template<typename T> T mod(T, double);
+template<typename T> T mod(T, T);
+template<typename T> T modf(T, T);
+template<typename T> T pow(T, T) RET;
+template<typename T> T round(T) RET;
+template<typename T> T smoothstep(T, T, T) RET;
+template<typename T> T sqrt(T) RET;
+template<typename T> T step(T) RET;
+template<typename T> T trunc(T) RET;
+template<typename T, typename U> T ldexp(T, U) RET;
+
+template<typename T> T acos(T) RET;
+template<typename T> T acosh(T) RET;
+template<typename T> T asin(T) RET;
+template<typename T> T asinh(T) RET;
+template<typename T> T atan(T, T) RET;
+template<typename T> T atan(T) RET;
+template<typename T> T atanh(T) RET;
+template<typename T> T cos(T) RET;
+template<typename T> T cosh(T) RET;
+template<typename T> T sin(T) RET;
+template<typename T> T sinh(T) RET;
+template<typename T> T tan(T) RET;
+template<typename T> T tanh(T) RET;
+
+template<typename T> T degrees(T) RET;
+template<typename T> T radians(T) RET;
+
+/* Declared explicitely to avoid type errors. */
+double mix(double, double, double) RET;
+template<int D> VecBase<double, D> mix(VecBase<double, D>, VecBase<double, D>, double) RET;
+template<typename T, int D> VecBase<T, D> mix(VecBase<T, D>, VecBase<T, D>, VecBase<bool, D>) RET;
+
+#define select(A, B, C) mix(A, B, C)
+
+VecBase<double, 3> cross(VecBase<double, 3>, VecBase<double, 3>) RET;
+template<int D> float dot(VecBase<double, D>, VecBase<double, D>) RET;
+template<int D> float distance(VecBase<double, D>, VecBase<double, D>) RET;
+template<int D> float length(VecBase<double, D>) RET;
+template<int D> VecBase<double, D> normalize(VecBase<double, D>) RET;
+
+template<int D> VecBase<int, D> floatBitsToInt(VecBase<double, D>) RET;
+template<int D> VecBase<uint, D> floatBitsToUint(VecBase<double, D>) RET;
+template<int D> VecBase<double, D> intBitsToFloat(VecBase<int, D>) RET;
+template<int D> VecBase<double, D> uintBitsToFloat(VecBase<uint, D>) RET;
+int floatBitsToInt(double) RET;
+uint floatBitsToUint(double) RET;
+double intBitsToFloat(int) RET;
+double uintBitsToFloat(uint) RET;
+
+namespace gl_FragmentShader {
+/* Derivative functions. */
+template<typename T> T dFdx(T) RET;
+template<typename T> T dFdy(T) RET;
+template<typename T> T fwidth(T) RET;
+}  // namespace gl_FragmentShader
+
+/* Geometric functions. */
+template<typename T, int D> float faceforward(VecBase<T, D>, VecBase<T, D>, VecBase<T, D>) RET;
+template<typename T, int D> float reflect(VecBase<T, D>, VecBase<T, D>) RET;
+template<typename T, int D> float refract(VecBase<T, D>, VecBase<T, D>, double) RET;
+
+/* Atomic operations. */
+int atomicAdd(int &, int) RET;
+int atomicAnd(int &, int) RET;
+int atomicOr(int &, int) RET;
+int atomicXor(int &, int) RET;
+int atomicMin(int &, int) RET;
+int atomicMax(int &, int) RET;
+int atomicExchange(int &, int) RET;
+int atomicCompSwap(int &, int, int) RET;
+uint atomicAdd(uint &, uint) RET;
+uint atomicAnd(uint &, uint) RET;
+uint atomicOr(uint &, uint) RET;
+uint atomicXor(uint &, uint) RET;
+uint atomicMin(uint &, uint) RET;
+uint atomicMax(uint &, uint) RET;
+uint atomicExchange(uint &, uint) RET;
+uint atomicCompSwap(uint &, uint, uint) RET;
+
+/* Packing functions. */
+uint packHalf2x16(float2) RET;
+uint packUnorm2x16(float2) RET;
+uint packSnorm2x16(float2) RET;
+uint packUnorm4x8(float4) RET;
+uint packSnorm4x8(float4) RET;
+float2 unpackHalf2x16(uint) RET;
+float2 unpackUnorm2x16(uint) RET;
+float2 unpackSnorm2x16(uint) RET;
+float4 unpackUnorm4x8(uint) RET;
+float4 unpackSnorm4x8(uint) RET;
+
+/* Matrices functions. */
+template<int C, int R> float determinant(MatBase<C, R>) RET;
+template<int C, int R> MatBase<C, R> inverse(MatBase<C, R>) RET;
+template<int C, int R> MatBase<R, C> transpose(MatBase<C, R>) RET;
+
+/* TODO(fclem): Should be in a lib instead of being impemented by each backend. */
+bool is_zero(vec2) RET;
+bool is_zero(vec3) RET;
+bool is_zero(vec4) RET;
+
+#undef RET
+
+/** \} */
+
+/* -------------------------------------------------------------------- */
+/** \name Special Variables
+ * \{ */
+
+namespace gl_VertexShader {
+
+const int gl_VertexID = 0;
+const int gl_InstanceID = 0;
+const int gl_BaseVertex = 0;
+const int gl_BaseInstance = 0;
+float4 gl_Position = float4(0);
+double gl_PointSize = 0;
+float gl_ClipDistance[6] = {0};
+int gpu_Layer = 0;
+int gpu_ViewportIndex = 0;
+
+}  // namespace gl_VertexShader
+
+namespace gl_FragmentShader {
+
+const float4 gl_FragCoord = float4(0);
+const bool gl_FrontFacing = true;
+const float2 gl_PointCoord = float2(0);
+const int gl_PrimitiveID = 0;
+float gl_FragDepth = 0;
+const float gl_ClipDistance[6] = {0};
+const int gpu_Layer = 0;
+const int gpu_ViewportIndex = 0;
+
+}  // namespace gl_FragmentShader
+
+namespace gl_ComputeShader {
+
+const uint3 gl_NumWorkGroups;
+constexpr uint3 gl_WorkGroupSize;
+const uint3 gl_WorkGroupID;
+const uint3 gl_LocalInvocationID;
+const uint3 gl_GlobalInvocationID;
+const uint gl_LocalInvocationIndex;
+
+}  // namespace gl_ComputeShader
+
+/** \} */
+
+/* -------------------------------------------------------------------- */
+/** \name Keywords
+ * \{ */
+
+/* Note: Cannot easily mutate them. Pass every by copy for now. */
+
+/* Pass argument by reference. */
+#define inout
+/* Pass argument by reference but only write to it. Its initial value is undefined. */
+#define out
+/* Pass argument by copy (default). */
+#define in
+
+/* Discards the output of the current fragment shader invocation and halts its execution. */
+#define discard
+
+/* Decorate a variable in global scope that is common to all threads in a threadgroup. */
+#define shared
+
+namespace gl_ComputeShader {
+void barrier() {}
+void memoryBarrier() {}
+void memoryBarrierShared() {}
+void memoryBarrierImage() {}
+void memoryBarrierBuffer() {}
+void groupMemoryBarrier() {}
+}  // namespace gl_ComputeShader
+
+/** \} */
+
+/* -------------------------------------------------------------------- */
+/** \name Compatibility
+ * \{ */
+
+/* Array syntax compatibility. */
+/* clang-format off */
+#define float_array(...) { __VA_ARGS__ }
+#define float2_array(...) { __VA_ARGS__ }
+#define float3_array(...) { __VA_ARGS__ }
+#define float4_array(...) { __VA_ARGS__ }
+#define int_array(...) { __VA_ARGS__ }
+#define int2_array(...) { __VA_ARGS__ }
+#define int3_array(...) { __VA_ARGS__ }
+#define int4_array(...) { __VA_ARGS__ }
+#define uint_array(...) { __VA_ARGS__ }
+#define uint2_array(...) { __VA_ARGS__ }
+#define uint3_array(...) { __VA_ARGS__ }
+#define uint4_array(...) { __VA_ARGS__ }
+#define bool_array(...) { __VA_ARGS__ }
+#define bool2_array(...) { __VA_ARGS__ }
+#define bool3_array(...) { __VA_ARGS__ }
+#define bool4_array(...) { __VA_ARGS__ }
+/* clang-format on */
+
+/** \} */
+
+#define GLSL_CPP_STUBS
+
+/* Include all shader shared files to that custom type definitions are available when create infos
+ * macros are included. Include them here so that only including this file is needed. */
+#include "GPU_shader_shared.hh"
+#include "draw_common_shader_shared.hh"
+#include "draw_shader_shared.hh"
+#include "eevee_shader_shared.hh"
+#include "overlay_shader_shared.h"
+#include "select_shader_shared.hh"
+#include "workbench_shader_shared.h"
+
+/* TODO(fclem): Include all create infos here so that they don't need to be individually included
+ * inside shaders. */
diff --git a/source/blender/gpu/shaders/metal/mtl_shader_defines.msl b/source/blender/gpu/shaders/metal/mtl_shader_defines.msl
index f605da8baa5..961fb63ad30 100644
--- a/source/blender/gpu/shaders/metal/mtl_shader_defines.msl
+++ b/source/blender/gpu/shaders/metal/mtl_shader_defines.msl
@@ -2529,3 +2529,23 @@ mat3x4 MAT3x4(mat2 m)
 #define MAT2 MAT2x2
 #define MAT3 MAT3x3
 #define MAT4 MAT4x4
+
+/* Array syntax compatibility. */
+/* clang-format off */
+#define float_array(...) { __VA_ARGS__ }
+#define float2_array(...) { __VA_ARGS__ }
+#define float3_array(...) { __VA_ARGS__ }
+#define float4_array(...) { __VA_ARGS__ }
+#define int_array(...) { __VA_ARGS__ }
+#define int2_array(...) { __VA_ARGS__ }
+#define int3_array(...) { __VA_ARGS__ }
+#define int4_array(...) { __VA_ARGS__ }
+#define uint_array(...) { __VA_ARGS__ }
+#define uint2_array(...) { __VA_ARGS__ }
+#define uint3_array(...) { __VA_ARGS__ }
+#define uint4_array(...) { __VA_ARGS__ }
+#define bool_array(...) { __VA_ARGS__ }
+#define bool2_array(...) { __VA_ARGS__ }
+#define bool3_array(...) { __VA_ARGS__ }
+#define bool4_array(...) { __VA_ARGS__ }
+/* clang-format on */
diff --git a/source/blender/gpu/shaders/opengl/glsl_shader_defines.glsl b/source/blender/gpu/shaders/opengl/glsl_shader_defines.glsl
index 29413d63605..9f10b4ba88d 100644
--- a/source/blender/gpu/shaders/opengl/glsl_shader_defines.glsl
+++ b/source/blender/gpu/shaders/opengl/glsl_shader_defines.glsl
@@ -103,3 +103,21 @@ bool is_zero(vec4 A)
 {
   return all(equal(A, vec4(0.0)));
 }
+
+/* Array syntax compatibility. */
+#define float_array float[]
+#define float2_array vec2[]
+#define float3_array vec3[]
+#define float4_array vec4[]
+#define int_array int[]
+#define int2_array int2[]
+#define int3_array int3[]
+#define int4_array int4[]
+#define uint_array uint[]
+#define uint2_array uint2[]
+#define uint3_array uint3[]
+#define uint4_array uint4[]
+#define bool_array bool[]
+#define bool2_array bool2[]
+#define bool3_array bool3[]
+#define bool4_array bool4[]