diff --git a/src/raymath.h b/src/raymath.h
index f246f26d9e52..3995cf1708a0 100644
--- a/src/raymath.h
+++ b/src/raymath.h
@@ -30,6 +30,9 @@
 *       #define RAYMATH_DISABLE_CPP_OPERATORS
 *           Disables C++ operator overloads for raymath types.
 *
+*       #define RAYMATH_NO_CONSTEXPR
+*           Disables declaring raymath functions as constexpr in C++, does nothing in C
+*
 *   LICENSE: zlib/libpng
 *
 *   Copyright (c) 2015-2025 Ramon Santamaria (@raysan5)
@@ -58,28 +61,33 @@
     #error "Specifying both RAYMATH_IMPLEMENTATION and RAYMATH_STATIC_INLINE is contradictory"
 #endif
 
+#if defined(__cplusplus) && !defined(RAYMATH_NO_CONSTEXPR)
+    #define RAYMATH_INLINE constexpr inline // Allow functions to be evaluated at compile time when using C++, unless disabled
+#else
+	#define RAYMATH_INLINE inline           // Plain inline in C
+#endif
+
 // Function specifiers definition
 #if defined(RAYMATH_IMPLEMENTATION)
     #if defined(_WIN32) && defined(BUILD_LIBTYPE_SHARED)
-        #define RMAPI __declspec(dllexport) extern inline // We are building raylib as a Win32 shared library (.dll)
+        #define RMAPI __declspec(dllexport) extern RAYMATH_INLINE // We are building raylib as a Win32 shared library (.dll)
     #elif defined(BUILD_LIBTYPE_SHARED)
         #define RMAPI __attribute__((visibility("default"))) // We are building raylib as a Unix shared library (.so/.dylib)
     #elif defined(_WIN32) && defined(USE_LIBTYPE_SHARED)
         #define RMAPI __declspec(dllimport)         // We are using raylib as a Win32 shared library (.dll)
     #else
-        #define RMAPI extern inline // Provide external definition
+        #define RMAPI extern RAYMATH_INLINE // Provide external definition
     #endif
 #elif defined(RAYMATH_STATIC_INLINE)
-    #define RMAPI static inline // Functions may be inlined, no external out-of-line definition
+    #define RMAPI static RAYMATH_INLINE // Functions may be inlined, no external out-of-line definition
 #else
     #if defined(__TINYC__)
-        #define RMAPI static inline // plain inline not supported by tinycc (See issue #435)
+        #define RMAPI static RAYMATH_INLINE // plain inline not supported by tinycc (See issue #435)
     #else
-        #define RMAPI inline        // Functions may be inlined or external definition used
+        #define RMAPI RAYMATH_INLINE        // Functions may be inlined or external definition used
     #endif
 #endif
 
-
 //----------------------------------------------------------------------------------
 // Defines and Macros
 //----------------------------------------------------------------------------------
@@ -2618,95 +2626,99 @@ RMAPI void MatrixDecompose(Matrix mat, Vector3 *translation, Quaternion *rotatio
 // Optional C++ math operators
 //-------------------------------------------------------------------------------
 
+#ifndef RMCPPOPAPI
+    #define RMCPPOPAPI RAYMATH_INLINE
+#endif
+
 // Vector2 operators
 static constexpr Vector2 Vector2Zeros = { 0, 0 };
 static constexpr Vector2 Vector2Ones = { 1, 1 };
 static constexpr Vector2 Vector2UnitX = { 1, 0 };
 static constexpr Vector2 Vector2UnitY = { 0, 1 };
 
-inline Vector2 operator + (const Vector2& lhs, const Vector2& rhs)
+RMCPPOPAPI Vector2 operator + (const Vector2& lhs, const Vector2& rhs)
 {
     return Vector2Add(lhs, rhs);
 }
 
-inline const Vector2& operator += (Vector2& lhs, const Vector2& rhs)
+RMCPPOPAPI const Vector2& operator += (Vector2& lhs, const Vector2& rhs)
 {
     lhs = Vector2Add(lhs, rhs);
     return lhs;
 }
 
-inline Vector2 operator - (const Vector2& lhs, const Vector2& rhs)
+RMCPPOPAPI Vector2 operator - (const Vector2& lhs, const Vector2& rhs)
 {
     return Vector2Subtract(lhs, rhs);
 }
 
-inline const Vector2& operator -= (Vector2& lhs, const Vector2& rhs)
+RMCPPOPAPI const Vector2& operator -= (Vector2& lhs, const Vector2& rhs)
 {
     lhs = Vector2Subtract(lhs, rhs);
     return lhs;
 }
 
-inline Vector2 operator * (const Vector2& lhs, const float& rhs)
+RMCPPOPAPI Vector2 operator * (const Vector2& lhs, const float& rhs)
 {
     return Vector2Scale(lhs, rhs);
 }
 
-inline const Vector2& operator *= (Vector2& lhs, const float& rhs)
+RMCPPOPAPI const Vector2& operator *= (Vector2& lhs, const float& rhs)
 {
     lhs = Vector2Scale(lhs, rhs);
     return lhs;
 }
 
-inline Vector2 operator * (const Vector2& lhs, const Vector2& rhs)
+RMCPPOPAPI Vector2 operator * (const Vector2& lhs, const Vector2& rhs)
 {
     return Vector2Multiply(lhs, rhs);
 }
 
-inline const Vector2& operator *= (Vector2& lhs, const Vector2& rhs)
+RMCPPOPAPI const Vector2& operator *= (Vector2& lhs, const Vector2& rhs)
 {
     lhs = Vector2Multiply(lhs, rhs);
     return lhs;
 }
 
-inline Vector2 operator * (const Vector2& lhs, const Matrix& rhs)
+RMCPPOPAPI Vector2 operator * (const Vector2& lhs, const Matrix& rhs)
 {
     return Vector2Transform(lhs, rhs);
 }
 
-inline const Vector2& operator *= (Vector2& lhs, const Matrix& rhs)
+RMCPPOPAPI const Vector2& operator *= (Vector2& lhs, const Matrix& rhs)
 {
     lhs = Vector2Transform(lhs, rhs);
     return lhs;
 }
 
-inline Vector2 operator / (const Vector2& lhs, const float& rhs)
+RMCPPOPAPI Vector2 operator / (const Vector2& lhs, const float& rhs)
 {
     return Vector2Scale(lhs, 1.0f/rhs);
 }
 
-inline const Vector2& operator /= (Vector2& lhs, const float& rhs)
+RMCPPOPAPI const Vector2& operator /= (Vector2& lhs, const float& rhs)
 {
     lhs = Vector2Scale(lhs, 1.0f/rhs);
     return lhs;
 }
 
-inline Vector2 operator / (const Vector2& lhs, const Vector2& rhs)
+RMCPPOPAPI Vector2 operator / (const Vector2& lhs, const Vector2& rhs)
 {
     return Vector2Divide(lhs, rhs);
 }
 
-inline const Vector2& operator /= (Vector2& lhs, const Vector2& rhs)
+RMCPPOPAPI const Vector2& operator /= (Vector2& lhs, const Vector2& rhs)
 {
     lhs = Vector2Divide(lhs, rhs);
     return lhs;
 }
 
-inline bool operator == (const Vector2& lhs, const Vector2& rhs)
+RMCPPOPAPI bool operator == (const Vector2& lhs, const Vector2& rhs)
 {
     return FloatEquals(lhs.x, rhs.x) && FloatEquals(lhs.y, rhs.y);
 }
 
-inline bool operator != (const Vector2& lhs, const Vector2& rhs)
+RMCPPOPAPI bool operator != (const Vector2& lhs, const Vector2& rhs)
 {
     return !FloatEquals(lhs.x, rhs.x) || !FloatEquals(lhs.y, rhs.y);
 }
@@ -2718,89 +2730,89 @@ static constexpr Vector3 Vector3UnitX = { 1, 0, 0 };
 static constexpr Vector3 Vector3UnitY = { 0, 1, 0 };
 static constexpr Vector3 Vector3UnitZ = { 0, 0, 1 };
 
-inline Vector3 operator + (const Vector3& lhs, const Vector3& rhs)
+RMCPPOPAPI Vector3 operator + (const Vector3& lhs, const Vector3& rhs)
 {
     return Vector3Add(lhs, rhs);
 }
 
-inline const Vector3& operator += (Vector3& lhs, const Vector3& rhs)
+RMCPPOPAPI const Vector3& operator += (Vector3& lhs, const Vector3& rhs)
 {
     lhs = Vector3Add(lhs, rhs);
     return lhs;
 }
 
-inline Vector3 operator - (const Vector3& lhs, const Vector3& rhs)
+RMCPPOPAPI Vector3 operator - (const Vector3& lhs, const Vector3& rhs)
 {
     return Vector3Subtract(lhs, rhs);
 }
 
-inline const Vector3& operator -= (Vector3& lhs, const Vector3& rhs)
+RMCPPOPAPI const Vector3& operator -= (Vector3& lhs, const Vector3& rhs)
 {
     lhs = Vector3Subtract(lhs, rhs);
     return lhs;
 }
 
-inline Vector3 operator * (const Vector3& lhs, const float& rhs)
+RMCPPOPAPI Vector3 operator * (const Vector3& lhs, const float& rhs)
 {
     return Vector3Scale(lhs, rhs);
 }
 
-inline const Vector3& operator *= (Vector3& lhs, const float& rhs)
+RMCPPOPAPI const Vector3& operator *= (Vector3& lhs, const float& rhs)
 {
     lhs = Vector3Scale(lhs, rhs);
     return lhs;
 }
 
-inline Vector3 operator * (const Vector3& lhs, const Vector3& rhs)
+RMCPPOPAPI Vector3 operator * (const Vector3& lhs, const Vector3& rhs)
 {
     return Vector3Multiply(lhs, rhs);
 }
 
-inline const Vector3& operator *= (Vector3& lhs, const Vector3& rhs)
+RMCPPOPAPI const Vector3& operator *= (Vector3& lhs, const Vector3& rhs)
 {
     lhs = Vector3Multiply(lhs, rhs);
     return lhs;
 }
 
-inline Vector3 operator * (const Vector3& lhs, const Matrix& rhs)
+RMCPPOPAPI Vector3 operator * (const Vector3& lhs, const Matrix& rhs)
 {
     return Vector3Transform(lhs, rhs);
 }
 
-inline const Vector3& operator *= (Vector3& lhs, const Matrix& rhs)
+RMCPPOPAPI const Vector3& operator *= (Vector3& lhs, const Matrix& rhs)
 {
     lhs = Vector3Transform(lhs, rhs);
     return lhs;
 }
 
-inline Vector3 operator / (const Vector3& lhs, const float& rhs)
+RMCPPOPAPI Vector3 operator / (const Vector3& lhs, const float& rhs)
 {
     return Vector3Scale(lhs, 1.0f/rhs);
 }
 
-inline const Vector3& operator /= (Vector3& lhs, const float& rhs)
+RMCPPOPAPI const Vector3& operator /= (Vector3& lhs, const float& rhs)
 {
     lhs = Vector3Scale(lhs, 1.0f/rhs);
     return lhs;
 }
 
-inline Vector3 operator / (const Vector3& lhs, const Vector3& rhs)
+RMCPPOPAPI Vector3 operator / (const Vector3& lhs, const Vector3& rhs)
 {
     return Vector3Divide(lhs, rhs);
 }
 
-inline const Vector3& operator /= (Vector3& lhs, const Vector3& rhs)
+RMCPPOPAPI const Vector3& operator /= (Vector3& lhs, const Vector3& rhs)
 {
     lhs = Vector3Divide(lhs, rhs);
     return lhs;
 }
 
-inline bool operator == (const Vector3& lhs, const Vector3& rhs)
+RMCPPOPAPI bool operator == (const Vector3& lhs, const Vector3& rhs)
 {
     return FloatEquals(lhs.x, rhs.x) && FloatEquals(lhs.y, rhs.y) && FloatEquals(lhs.z, rhs.z);
 }
 
-inline bool operator != (const Vector3& lhs, const Vector3& rhs)
+RMCPPOPAPI bool operator != (const Vector3& lhs, const Vector3& rhs)
 {
     return !FloatEquals(lhs.x, rhs.x) || !FloatEquals(lhs.y, rhs.y) || !FloatEquals(lhs.z, rhs.z);
 }
@@ -2813,78 +2825,78 @@ static constexpr Vector4 Vector4UnitY = { 0, 1, 0, 0 };
 static constexpr Vector4 Vector4UnitZ = { 0, 0, 1, 0 };
 static constexpr Vector4 Vector4UnitW = { 0, 0, 0, 1 };
 
-inline Vector4 operator + (const Vector4& lhs, const Vector4& rhs)
+RMCPPOPAPI Vector4 operator + (const Vector4& lhs, const Vector4& rhs)
 {
     return Vector4Add(lhs, rhs);
 }
 
-inline const Vector4& operator += (Vector4& lhs, const Vector4& rhs)
+RMCPPOPAPI const Vector4& operator += (Vector4& lhs, const Vector4& rhs)
 {
     lhs = Vector4Add(lhs, rhs);
     return lhs;
 }
 
-inline Vector4 operator - (const Vector4& lhs, const Vector4& rhs)
+RMCPPOPAPI Vector4 operator - (const Vector4& lhs, const Vector4& rhs)
 {
     return Vector4Subtract(lhs, rhs);
 }
 
-inline const Vector4& operator -= (Vector4& lhs, const Vector4& rhs)
+RMCPPOPAPI const Vector4& operator -= (Vector4& lhs, const Vector4& rhs)
 {
     lhs = Vector4Subtract(lhs, rhs);
     return lhs;
 }
 
-inline Vector4 operator * (const Vector4& lhs, const float& rhs)
+RMCPPOPAPI Vector4 operator * (const Vector4& lhs, const float& rhs)
 {
     return Vector4Scale(lhs, rhs);
 }
 
-inline const Vector4& operator *= (Vector4& lhs, const float& rhs)
+RMCPPOPAPI const Vector4& operator *= (Vector4& lhs, const float& rhs)
 {
     lhs = Vector4Scale(lhs, rhs);
     return lhs;
 }
 
-inline Vector4 operator * (const Vector4& lhs, const Vector4& rhs)
+RMCPPOPAPI Vector4 operator * (const Vector4& lhs, const Vector4& rhs)
 {
     return Vector4Multiply(lhs, rhs);
 }
 
-inline const Vector4& operator *= (Vector4& lhs, const Vector4& rhs)
+RMCPPOPAPI const Vector4& operator *= (Vector4& lhs, const Vector4& rhs)
 {
     lhs = Vector4Multiply(lhs, rhs);
     return lhs;
 }
 
-inline Vector4 operator / (const Vector4& lhs, const float& rhs)
+RMCPPOPAPI Vector4 operator / (const Vector4& lhs, const float& rhs)
 {
     return Vector4Scale(lhs, 1.0f/rhs);
 }
 
-inline const Vector4& operator /= (Vector4& lhs, const float& rhs)
+RMCPPOPAPI const Vector4& operator /= (Vector4& lhs, const float& rhs)
 {
     lhs = Vector4Scale(lhs, 1.0f/rhs);
     return lhs;
 }
 
-inline Vector4 operator / (const Vector4& lhs, const Vector4& rhs)
+RMCPPOPAPI Vector4 operator / (const Vector4& lhs, const Vector4& rhs)
 {
     return Vector4Divide(lhs, rhs);
 }
 
-inline const Vector4& operator /= (Vector4& lhs, const Vector4& rhs)
+RMCPPOPAPI const Vector4& operator /= (Vector4& lhs, const Vector4& rhs)
 {
     lhs = Vector4Divide(lhs, rhs);
     return lhs;
 }
 
-inline bool operator == (const Vector4& lhs, const Vector4& rhs)
+RMCPPOPAPI bool operator == (const Vector4& lhs, const Vector4& rhs)
 {
     return FloatEquals(lhs.x, rhs.x) && FloatEquals(lhs.y, rhs.y) && FloatEquals(lhs.z, rhs.z) && FloatEquals(lhs.w, rhs.w);
 }
 
-inline bool operator != (const Vector4& lhs, const Vector4& rhs)
+RMCPPOPAPI bool operator != (const Vector4& lhs, const Vector4& rhs)
 {
     return !FloatEquals(lhs.x, rhs.x) || !FloatEquals(lhs.y, rhs.y) || !FloatEquals(lhs.z, rhs.z) || !FloatEquals(lhs.w, rhs.w);
 }
@@ -2894,68 +2906,68 @@ static constexpr Quaternion QuaternionZeros = { 0, 0, 0, 0 };
 static constexpr Quaternion QuaternionOnes = { 1, 1, 1, 1 };
 static constexpr Quaternion QuaternionUnitX = { 0, 0, 0, 1 };
 
-inline Quaternion operator + (const Quaternion& lhs, const float& rhs)
+RMCPPOPAPI Quaternion operator + (const Quaternion& lhs, const float& rhs)
 {
     return QuaternionAddValue(lhs, rhs);
 }
 
-inline const Quaternion& operator += (Quaternion& lhs, const float& rhs)
+RMCPPOPAPI const Quaternion& operator += (Quaternion& lhs, const float& rhs)
 {
     lhs = QuaternionAddValue(lhs, rhs);
     return lhs;
 }
 
-inline Quaternion operator - (const Quaternion& lhs, const float& rhs)
+RMCPPOPAPI Quaternion operator - (const Quaternion& lhs, const float& rhs)
 {
     return QuaternionSubtractValue(lhs, rhs);
 }
 
-inline const Quaternion& operator -= (Quaternion& lhs, const float& rhs)
+RMCPPOPAPI const Quaternion& operator -= (Quaternion& lhs, const float& rhs)
 {
     lhs = QuaternionSubtractValue(lhs, rhs);
     return lhs;
 }
 
-inline Quaternion operator * (const Quaternion& lhs, const Matrix& rhs)
+RMCPPOPAPI Quaternion operator * (const Quaternion& lhs, const Matrix& rhs)
 {
     return QuaternionTransform(lhs, rhs);
 }
 
-inline const Quaternion& operator *= (Quaternion& lhs, const Matrix& rhs)
+RMCPPOPAPI const Quaternion& operator *= (Quaternion& lhs, const Matrix& rhs)
 {
     lhs = QuaternionTransform(lhs, rhs);
     return lhs;
 }
 
 // Matrix operators
-inline Matrix operator + (const Matrix& lhs, const Matrix& rhs)
+RMCPPOPAPI Matrix operator + (const Matrix& lhs, const Matrix& rhs)
 {
     return MatrixAdd(lhs, rhs);
 }
 
-inline const Matrix& operator += (Matrix& lhs, const Matrix& rhs)
+RMCPPOPAPI const Matrix& operator += (Matrix& lhs, const Matrix& rhs)
 {
     lhs = MatrixAdd(lhs, rhs);
     return lhs;
 }
 
-inline Matrix operator - (const Matrix& lhs, const Matrix& rhs)
+RMCPPOPAPI Matrix operator - (const Matrix& lhs, const Matrix& rhs)
 {
     return MatrixSubtract(lhs, rhs);
 }
 
-inline const Matrix& operator -= (Matrix& lhs, const Matrix& rhs)
+RMCPPOPAPI const Matrix& operator -= (Matrix& lhs, const Matrix& rhs)
 {
     lhs = MatrixSubtract(lhs, rhs);
     return lhs;
 }
 
-inline Matrix operator * (const Matrix& lhs, const Matrix& rhs)
+RMCPPOPAPI Matrix operator * (const Matrix& lhs, const Matrix& rhs)
 {
     return MatrixMultiply(lhs, rhs);
 }
 
-inline const Matrix& operator *= (Matrix& lhs, const Matrix& rhs)
+RMCPPOPAPI const Matrix& operator *= (Matrix& lhs, const Matrix& rhs)
 {
     lhs = MatrixMultiply(lhs, rhs);
     return lhs;