diff --git a/src/coreclr/jit/hwintrinsicarm64.cpp b/src/coreclr/jit/hwintrinsicarm64.cpp
index fac3e6c6216fe1..17637cad75039f 100644
--- a/src/coreclr/jit/hwintrinsicarm64.cpp
+++ b/src/coreclr/jit/hwintrinsicarm64.cpp
@@ -709,6 +709,30 @@ GenTree* Compiler::impSpecialIntrinsic(NamedIntrinsic        intrinsic,
             break;
         }
 
+        case NI_Vector64_AddSaturate:
+        case NI_Vector128_AddSaturate:
+        {
+            assert(sig->numArgs == 2);
+
+            if (simdSize == 8 && varTypeIsLong(simdBaseType))
+            {
+                break;
+            }
+
+            op2 = impSIMDPopStack();
+            op1 = impSIMDPopStack();
+            if (varTypeIsFloating(simdBaseType))
+            {
+                retNode = gtNewSimdBinOpNode(GT_ADD, retType, op1, op2, simdBaseJitType, simdSize);
+            }
+            else
+            {
+                retNode =
+                    gtNewSimdHWIntrinsicNode(retType, op1, op2, NI_AdvSimd_AddSaturate, simdBaseJitType, simdSize);
+            }
+            break;
+        }
+
         case NI_AdvSimd_BitwiseClear:
         case NI_Vector64_AndNot:
         case NI_Vector128_AndNot:
@@ -2097,6 +2121,30 @@ GenTree* Compiler::impSpecialIntrinsic(NamedIntrinsic        intrinsic,
             break;
         }
 
+        case NI_Vector64_SubtractSaturate:
+        case NI_Vector128_SubtractSaturate:
+        {
+            assert(sig->numArgs == 2);
+
+            if (simdSize == 8 && varTypeIsLong(simdBaseType))
+            {
+                break;
+            }
+
+            op2 = impSIMDPopStack();
+            op1 = impSIMDPopStack();
+            if (varTypeIsFloating(simdBaseType))
+            {
+                retNode = gtNewSimdBinOpNode(GT_SUB, retType, op1, op2, simdBaseJitType, simdSize);
+            }
+            else
+            {
+                retNode =
+                    gtNewSimdHWIntrinsicNode(retType, op1, op2, NI_AdvSimd_SubtractSaturate, simdBaseJitType, simdSize);
+            }
+            break;
+        }
+
         case NI_Vector64_op_LeftShift:
         case NI_Vector128_op_LeftShift:
         {
diff --git a/src/coreclr/jit/hwintrinsiclistarm64.h b/src/coreclr/jit/hwintrinsiclistarm64.h
index 3f8c9ebf40dfaa..7694bb3bab3481 100644
--- a/src/coreclr/jit/hwintrinsiclistarm64.h
+++ b/src/coreclr/jit/hwintrinsiclistarm64.h
@@ -17,6 +17,7 @@
 //  Vector64 Intrinsics
 #define FIRST_NI_Vector64         NI_Vector64_Abs
 HARDWARE_INTRINSIC(Vector64,      Abs,                                                               8,      1,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_InvalidNodeId)
+HARDWARE_INTRINSIC(Vector64,      AddSaturate,                                                       8,      2,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_InvalidNodeId)
 HARDWARE_INTRINSIC(Vector64,      AndNot,                                                            8,      2,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_InvalidNodeId)
 HARDWARE_INTRINSIC(Vector64,      As,                                                                8,      1,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_InvalidNodeId|HW_Flag_BaseTypeFromFirstArg)
 HARDWARE_INTRINSIC(Vector64,      AsByte,                                                            8,      1,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_InvalidNodeId|HW_Flag_BaseTypeFromFirstArg)
@@ -86,6 +87,7 @@ HARDWARE_INTRINSIC(Vector64,      Sqrt,
 HARDWARE_INTRINSIC(Vector64,      StoreAligned,                                                      8,      2,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_InvalidNodeId|HW_Flag_BaseTypeFromFirstArg)
 HARDWARE_INTRINSIC(Vector64,      StoreAlignedNonTemporal,                                           8,      2,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_InvalidNodeId|HW_Flag_BaseTypeFromFirstArg)
 HARDWARE_INTRINSIC(Vector64,      StoreUnsafe,                                                       8,     -1,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_InvalidNodeId|HW_Flag_BaseTypeFromFirstArg)
+HARDWARE_INTRINSIC(Vector64,      SubtractSaturate,                                                  8,      2,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_InvalidNodeId)
 HARDWARE_INTRINSIC(Vector64,      Sum,                                                               8,      1,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_InvalidNodeId|HW_Flag_BaseTypeFromFirstArg)
 HARDWARE_INTRINSIC(Vector64,      ToScalar,                                                          8,      1,     {INS_smov,           INS_umov,           INS_smov,           INS_umov,           INS_smov,           INS_umov,           INS_umov,           INS_umov,           INS_dup,            INS_dup},         HW_Category_SIMD,                  HW_Flag_BaseTypeFromFirstArg|HW_Flag_SIMDScalar|HW_Flag_SpecialCodeGen)
 HARDWARE_INTRINSIC(Vector64,      ToVector128,                                                       8,      1,     {INS_mov,            INS_mov,            INS_mov,            INS_mov,            INS_mov,            INS_mov,            INS_mov,            INS_mov,            INS_mov,            INS_mov},         HW_Category_SIMD,                  HW_Flag_SpecialCodeGen)
@@ -122,6 +124,7 @@ HARDWARE_INTRINSIC(Vector64,      op_UnsignedRightShift,
 //  Vector128 Intrinsics
 #define FIRST_NI_Vector128        NI_Vector128_Abs
 HARDWARE_INTRINSIC(Vector128,     Abs,                                                              16,      1,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_InvalidNodeId)
+HARDWARE_INTRINSIC(Vector128,     AddSaturate,                                                      16,      2,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_InvalidNodeId)
 HARDWARE_INTRINSIC(Vector128,     AndNot,                                                           16,      2,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_InvalidNodeId)
 HARDWARE_INTRINSIC(Vector128,     As,                                                               16,      1,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_InvalidNodeId|HW_Flag_BaseTypeFromFirstArg)
 HARDWARE_INTRINSIC(Vector128,     AsByte,                                                           16,      1,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_InvalidNodeId|HW_Flag_BaseTypeFromFirstArg)
@@ -199,6 +202,7 @@ HARDWARE_INTRINSIC(Vector128,     Sqrt,
 HARDWARE_INTRINSIC(Vector128,     StoreAligned,                                                     16,      2,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_InvalidNodeId|HW_Flag_BaseTypeFromFirstArg)
 HARDWARE_INTRINSIC(Vector128,     StoreAlignedNonTemporal,                                          16,      2,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_InvalidNodeId|HW_Flag_BaseTypeFromFirstArg)
 HARDWARE_INTRINSIC(Vector128,     StoreUnsafe,                                                      16,     -1,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_InvalidNodeId|HW_Flag_BaseTypeFromFirstArg)
+HARDWARE_INTRINSIC(Vector128,     SubtractSaturate,                                                 16,      2,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_InvalidNodeId)
 HARDWARE_INTRINSIC(Vector128,     Sum,                                                              16,      1,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_InvalidNodeId|HW_Flag_BaseTypeFromFirstArg)
 HARDWARE_INTRINSIC(Vector128,     ToScalar,                                                         16,      1,     {INS_smov,           INS_umov,           INS_smov,           INS_umov,           INS_smov,           INS_umov,           INS_umov,           INS_umov,           INS_dup,            INS_dup},         HW_Category_SIMD,                  HW_Flag_BaseTypeFromFirstArg|HW_Flag_SIMDScalar|HW_Flag_SpecialCodeGen)
 HARDWARE_INTRINSIC(Vector128,     Truncate,                                                         16,      1,     {INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid,        INS_invalid},     HW_Category_Helper,                HW_Flag_InvalidNodeId)
diff --git a/src/coreclr/jit/hwintrinsiclistxarch.h b/src/coreclr/jit/hwintrinsiclistxarch.h
index cf1562838b9807..4b5f90f7cb3409 100644
--- a/src/coreclr/jit/hwintrinsiclistxarch.h
+++ b/src/coreclr/jit/hwintrinsiclistxarch.h
@@ -29,6 +29,7 @@
 //  Vector128 Intrinsics
 #define FIRST_NI_Vector128          NI_Vector128_Abs
 HARDWARE_INTRINSIC(Vector128,       Abs,                                        16,             1,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId)
+HARDWARE_INTRINSIC(Vector128,       AddSaturate,                                16,             2,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId)
 HARDWARE_INTRINSIC(Vector128,       AndNot,                                     16,             2,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId)
 HARDWARE_INTRINSIC(Vector128,       As,                                         16,             1,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId|HW_Flag_BaseTypeFromFirstArg)
 HARDWARE_INTRINSIC(Vector128,       AsByte,                                     16,             1,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId|HW_Flag_BaseTypeFromFirstArg)
@@ -104,6 +105,7 @@ HARDWARE_INTRINSIC(Vector128,       Sqrt,
 HARDWARE_INTRINSIC(Vector128,       StoreAligned,                               16,             2,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId|HW_Flag_BaseTypeFromFirstArg)
 HARDWARE_INTRINSIC(Vector128,       StoreAlignedNonTemporal,                    16,             2,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId|HW_Flag_BaseTypeFromFirstArg)
 HARDWARE_INTRINSIC(Vector128,       StoreUnsafe,                                16,            -1,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId|HW_Flag_BaseTypeFromFirstArg)
+HARDWARE_INTRINSIC(Vector128,       SubtractSaturate,                           16,             2,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId)
 HARDWARE_INTRINSIC(Vector128,       Sum,                                        16,             1,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId|HW_Flag_BaseTypeFromFirstArg)
 HARDWARE_INTRINSIC(Vector128,       ToScalar,                                   16,             1,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_movss,              INS_movsd_simd},        HW_Category_SIMDScalar,             HW_Flag_SpecialImport|HW_Flag_SpecialCodeGen|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics)
 HARDWARE_INTRINSIC(Vector128,       ToVector256,                                16,             1,      {INS_movdqu,            INS_movdqu,             INS_movdqu,             INS_movdqu,             INS_movdqu,             INS_movdqu,             INS_movdqu,             INS_movdqu,             INS_movups,             INS_movupd},            HW_Category_SimpleSIMD,             HW_Flag_SpecialImport|HW_Flag_SpecialCodeGen|HW_Flag_BaseTypeFromFirstArg|HW_Flag_NoRMWSemantics)
@@ -141,6 +143,7 @@ HARDWARE_INTRINSIC(Vector128,       op_UnsignedRightShift,
 //  Vector256 Intrinsics
 #define FIRST_NI_Vector256          NI_Vector256_Abs
 HARDWARE_INTRINSIC(Vector256,       Abs,                                        32,             1,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId)
+HARDWARE_INTRINSIC(Vector256,       AddSaturate,                                32,             2,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId)
 HARDWARE_INTRINSIC(Vector256,       AndNot,                                     32,             2,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId|HW_Flag_AvxOnlyCompatible)
 HARDWARE_INTRINSIC(Vector256,       As,                                         32,             1,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId|HW_Flag_BaseTypeFromFirstArg|HW_Flag_AvxOnlyCompatible)
 HARDWARE_INTRINSIC(Vector256,       AsByte,                                     32,             1,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId|HW_Flag_BaseTypeFromFirstArg|HW_Flag_AvxOnlyCompatible)
@@ -214,6 +217,7 @@ HARDWARE_INTRINSIC(Vector256,       Sqrt,
 HARDWARE_INTRINSIC(Vector256,       StoreAligned,                               32,             2,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId|HW_Flag_BaseTypeFromFirstArg|HW_Flag_AvxOnlyCompatible)
 HARDWARE_INTRINSIC(Vector256,       StoreAlignedNonTemporal,                    32,             2,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId|HW_Flag_BaseTypeFromFirstArg|HW_Flag_AvxOnlyCompatible)
 HARDWARE_INTRINSIC(Vector256,       StoreUnsafe,                                32,            -1,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId|HW_Flag_BaseTypeFromFirstArg|HW_Flag_AvxOnlyCompatible)
+HARDWARE_INTRINSIC(Vector256,       SubtractSaturate,                           32,             2,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId)
 HARDWARE_INTRINSIC(Vector256,       Sum,                                        32,             1,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId|HW_Flag_BaseTypeFromFirstArg)
 HARDWARE_INTRINSIC(Vector256,       ToScalar,                                   32,             1,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_movss,              INS_movsd_simd},        HW_Category_SIMDScalar,             HW_Flag_SpecialImport|HW_Flag_SpecialCodeGen|HW_Flag_BaseTypeFromFirstArg|HW_Flag_AvxOnlyCompatible)
 HARDWARE_INTRINSIC(Vector256,       ToVector512,                                32,             1,      {INS_movdqu,            INS_movdqu,             INS_movdqu,             INS_movdqu,             INS_movdqu,             INS_movdqu,             INS_vmovdqu64,          INS_vmovdqu64,          INS_movups,             INS_movupd},            HW_Category_SimpleSIMD,             HW_Flag_SpecialImport|HW_Flag_SpecialCodeGen|HW_Flag_BaseTypeFromFirstArg)
@@ -252,6 +256,7 @@ HARDWARE_INTRINSIC(Vector256,       op_UnsignedRightShift,
 //  Vector512 Intrinsics
 #define FIRST_NI_Vector512          NI_Vector512_Abs
 HARDWARE_INTRINSIC(Vector512,       Abs,                                        64,             1,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId)
+HARDWARE_INTRINSIC(Vector512,       AddSaturate,                                64,             2,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId)
 HARDWARE_INTRINSIC(Vector512,       AndNot,                                     64,             2,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId)
 HARDWARE_INTRINSIC(Vector512,       As,                                         64,             1,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId|HW_Flag_BaseTypeFromFirstArg)
 HARDWARE_INTRINSIC(Vector512,       AsByte,                                     64,             1,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId|HW_Flag_BaseTypeFromFirstArg)
@@ -325,6 +330,7 @@ HARDWARE_INTRINSIC(Vector512,       Sqrt,
 HARDWARE_INTRINSIC(Vector512,       StoreAligned,                               64,             2,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId|HW_Flag_BaseTypeFromFirstArg)
 HARDWARE_INTRINSIC(Vector512,       StoreAlignedNonTemporal,                    64,             2,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId|HW_Flag_BaseTypeFromFirstArg)
 HARDWARE_INTRINSIC(Vector512,       StoreUnsafe,                                64,            -1,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId|HW_Flag_BaseTypeFromFirstArg)
+HARDWARE_INTRINSIC(Vector512,       SubtractSaturate,                           64,             2,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId)
 HARDWARE_INTRINSIC(Vector512,       Sum,                                        64,             1,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId|HW_Flag_BaseTypeFromFirstArg)
 HARDWARE_INTRINSIC(Vector512,       ToScalar,                                   64,             1,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_movss,              INS_movsd_simd},        HW_Category_SIMDScalar,             HW_Flag_SpecialImport|HW_Flag_SpecialCodeGen|HW_Flag_BaseTypeFromFirstArg)
 HARDWARE_INTRINSIC(Vector512,       Truncate,                                   64,             1,      {INS_invalid,           INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid,            INS_invalid},           HW_Category_Helper,                 HW_Flag_InvalidNodeId)
diff --git a/src/coreclr/jit/hwintrinsicxarch.cpp b/src/coreclr/jit/hwintrinsicxarch.cpp
index 8c5f27234053f4..70517187535d72 100644
--- a/src/coreclr/jit/hwintrinsicxarch.cpp
+++ b/src/coreclr/jit/hwintrinsicxarch.cpp
@@ -1384,6 +1384,44 @@ GenTree* Compiler::impSpecialIntrinsic(NamedIntrinsic        intrinsic,
             break;
         }
 
+        case NI_Vector128_AddSaturate:
+        case NI_Vector256_AddSaturate:
+        case NI_Vector512_AddSaturate:
+        {
+            assert(sig->numArgs == 2);
+
+            if (varTypeIsFloating(simdBaseType))
+            {
+                op2     = impSIMDPopStack();
+                op1     = impSIMDPopStack();
+                retNode = gtNewSimdBinOpNode(GT_ADD, retType, op1, op2, simdBaseJitType, simdSize);
+            }
+            else if (varTypeIsByte(simdBaseType) || varTypeIsShort(simdBaseType))
+            {
+                intrinsic = NI_Illegal;
+                if (simdSize == 16 && compOpportunisticallyDependsOn(InstructionSet_SSE2))
+                {
+                    intrinsic = NI_SSE2_AddSaturate;
+                }
+                else if (simdSize == 32 && compOpportunisticallyDependsOn(InstructionSet_AVX2))
+                {
+                    intrinsic = NI_AVX2_AddSaturate;
+                }
+                else if (simdSize == 64 && compOpportunisticallyDependsOn(InstructionSet_AVX512BW))
+                {
+                    intrinsic = NI_AVX512BW_AddSaturate;
+                }
+
+                if (intrinsic != NI_Illegal)
+                {
+                    op2     = impSIMDPopStack();
+                    op1     = impSIMDPopStack();
+                    retNode = gtNewSimdHWIntrinsicNode(retType, op1, op2, intrinsic, simdBaseJitType, simdSize);
+                }
+            }
+            break;
+        }
+
         case NI_SSE_AndNot:
         case NI_SSE2_AndNot:
         case NI_AVX_AndNot:
@@ -3615,6 +3653,44 @@ GenTree* Compiler::impSpecialIntrinsic(NamedIntrinsic        intrinsic,
             break;
         }
 
+        case NI_Vector128_SubtractSaturate:
+        case NI_Vector256_SubtractSaturate:
+        case NI_Vector512_SubtractSaturate:
+        {
+            assert(sig->numArgs == 2);
+
+            if (varTypeIsFloating(simdBaseType))
+            {
+                op2     = impSIMDPopStack();
+                op1     = impSIMDPopStack();
+                retNode = gtNewSimdBinOpNode(GT_SUB, retType, op1, op2, simdBaseJitType, simdSize);
+            }
+            else if (varTypeIsByte(simdBaseType) || varTypeIsShort(simdBaseType))
+            {
+                intrinsic = NI_Illegal;
+                if (simdSize == 16 && compOpportunisticallyDependsOn(InstructionSet_SSE2))
+                {
+                    intrinsic = NI_SSE2_SubtractSaturate;
+                }
+                else if (simdSize == 32 && compOpportunisticallyDependsOn(InstructionSet_AVX2))
+                {
+                    intrinsic = NI_AVX2_SubtractSaturate;
+                }
+                else if (simdSize == 64 && compOpportunisticallyDependsOn(InstructionSet_AVX512BW))
+                {
+                    intrinsic = NI_AVX512BW_SubtractSaturate;
+                }
+
+                if (intrinsic != NI_Illegal)
+                {
+                    op2     = impSIMDPopStack();
+                    op1     = impSIMDPopStack();
+                    retNode = gtNewSimdHWIntrinsicNode(retType, op1, op2, intrinsic, simdBaseJitType, simdSize);
+                }
+            }
+            break;
+        }
+
         case NI_Vector128_Sum:
         case NI_Vector256_Sum:
         case NI_Vector512_Sum:
diff --git a/src/libraries/Common/tests/System/GenericMathTestMemberData.cs b/src/libraries/Common/tests/System/GenericMathTestMemberData.cs
index 0e19ac826dfdda..97f44771ca8c38 100644
--- a/src/libraries/Common/tests/System/GenericMathTestMemberData.cs
+++ b/src/libraries/Common/tests/System/GenericMathTestMemberData.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Collections.Generic;
+using System.Numerics;
 using Xunit;
 
 namespace System.Tests
@@ -1927,5 +1928,220 @@ public static IEnumerable<object[]> TruncateSingle
                 yield return new object[] { -3.14159f,  -3.0f };
             }
         }
+
+        public static IEnumerable<object[]> AddSaturateSByte => AddSaturateSignedInteger<sbyte>();
+        public static IEnumerable<object[]> AddSaturateInt16 => AddSaturateSignedInteger<short>();
+        public static IEnumerable<object[]> AddSaturateInt32 => AddSaturateSignedInteger<int>();
+        public static IEnumerable<object[]> AddSaturateInt64 => AddSaturateSignedInteger<long>();
+
+        private static IEnumerable<object[]> AddSaturateSignedInteger<T>() where T : INumber<T>, IMinMaxValue<T>
+        {
+            yield return new object[] { T.Zero, T.Zero, T.Zero };
+            yield return new object[] { T.Zero, T.CreateChecked(10), T.CreateChecked(10) };
+            yield return new object[] { T.Zero, T.CreateChecked(-10), T.CreateChecked(-10) };
+            yield return new object[] { T.Zero, T.MinValue, T.MinValue };
+            yield return new object[] { T.Zero, T.MaxValue, T.MaxValue };
+
+            yield return new object[] { T.CreateChecked(10), T.Zero, T.CreateChecked(10) };
+            yield return new object[] { T.CreateChecked(10), T.CreateChecked(5), T.CreateChecked(15) };
+            yield return new object[] { T.CreateChecked(10), T.CreateChecked(-5), T.CreateChecked(5) };
+            yield return new object[] { T.CreateChecked(10), T.MinValue, T.MinValue + T.CreateChecked(10) };
+            yield return new object[] { T.CreateChecked(10), T.MaxValue, T.MaxValue };
+            yield return new object[] { T.CreateChecked(10), T.MaxValue - T.CreateChecked(5), T.MaxValue };
+
+            yield return new object[] { T.CreateChecked(-10), T.Zero, T.CreateChecked(-10) };
+            yield return new object[] { T.CreateChecked(-10), T.CreateChecked(5), T.CreateChecked(-5) };
+            yield return new object[] { T.CreateChecked(-10), T.CreateChecked(-5), T.CreateChecked(-15) };
+            yield return new object[] { T.CreateChecked(-10), T.MinValue, T.MinValue };
+            yield return new object[] { T.CreateChecked(-10), T.MaxValue, T.MaxValue - T.CreateChecked(10) };
+
+            yield return new object[] { T.MinValue, T.Zero, T.MinValue };
+            yield return new object[] { T.MinValue, T.CreateChecked(10), T.MinValue + T.CreateChecked(10) };
+            yield return new object[] { T.MinValue, T.CreateChecked(-10), T.MinValue };
+            yield return new object[] { T.MinValue, T.MinValue, T.MinValue };
+            yield return new object[] { T.MinValue, T.MaxValue, -T.One };
+
+            yield return new object[] { T.MaxValue, T.Zero, T.MaxValue };
+            yield return new object[] { T.MaxValue, T.CreateChecked(10), T.MaxValue };
+            yield return new object[] { T.MaxValue, T.CreateChecked(-10), T.MaxValue - T.CreateChecked(10) };
+            yield return new object[] { T.MaxValue, T.MinValue, -T.One };
+            yield return new object[] { T.MaxValue, T.MaxValue, T.MaxValue };
+
+            yield return new object[] { T.MaxValue - T.CreateChecked(5), T.CreateChecked(10), T.MaxValue };
+        }
+
+        public static IEnumerable<object[]> AddSaturateByte => AddSaturateUnsignedInteger<byte>();
+        public static IEnumerable<object[]> AddSaturateUInt16 => AddSaturateUnsignedInteger<ushort>();
+        public static IEnumerable<object[]> AddSaturateUInt32 => AddSaturateUnsignedInteger<uint>();
+        public static IEnumerable<object[]> AddSaturateUInt64 => AddSaturateUnsignedInteger<ulong>();
+
+        private static IEnumerable<object[]> AddSaturateUnsignedInteger<T>() where T : INumber<T>, IMinMaxValue<T>
+        {
+            yield return new object[] { T.Zero, T.Zero, T.Zero };
+            yield return new object[] { T.Zero, T.CreateChecked(10), T.CreateChecked(10) };
+            yield return new object[] { T.Zero, T.MaxValue, T.MaxValue };
+
+            yield return new object[] { T.CreateChecked(10), T.Zero, T.CreateChecked(10) };
+            yield return new object[] { T.CreateChecked(10), T.CreateChecked(5), T.CreateChecked(15) };
+            yield return new object[] { T.CreateChecked(10), T.MaxValue - T.CreateChecked(5), T.MaxValue };
+            yield return new object[] { T.CreateChecked(10), T.MaxValue, T.MaxValue };
+
+            yield return new object[] { T.MaxValue, T.Zero, T.MaxValue };
+            yield return new object[] { T.MaxValue, T.CreateChecked(10), T.MaxValue };
+            yield return new object[] { T.MaxValue, T.MaxValue, T.MaxValue };
+
+            yield return new object[] { T.MaxValue - T.CreateChecked(5), T.CreateChecked(10), T.MaxValue };
+        }
+
+        public static IEnumerable<object[]> AddSaturateDouble
+        {
+            get
+            {
+                yield return new object[] { double.NegativeInfinity, 1.0, double.NegativeInfinity };
+                yield return new object[] { double.MinValue, 1.0, double.MinValue };
+                yield return new object[] { -1.0, 1.0, 0.0 };
+                yield return new object[] { -MinNormalDouble, 1.0, 1.0 };
+                yield return new object[] { -MaxSubnormalDouble, 1.0, 1.0 };
+                yield return new object[] { -double.Epsilon, 1.0, 1.0 };
+                yield return new object[] { -0.0, 1.0, 1.0 };
+                yield return new object[] { double.NaN, 1.0, double.NaN };
+                yield return new object[] { 0.0, 1.0, 1.0 };
+                yield return new object[] { double.Epsilon, 1.0, 1.0 };
+                yield return new object[] { MaxSubnormalDouble, 1.0, 1.0 };
+                yield return new object[] { MinNormalDouble, 1.0, 1.0 };
+                yield return new object[] { 1.0, 1.0, 2.0 };
+                yield return new object[] { double.MaxValue, 1.0, double.MaxValue };
+                yield return new object[] { double.PositiveInfinity, 1.0, double.PositiveInfinity };
+            }
+        }
+
+        public static IEnumerable<object[]> AddSaturateSingle
+        {
+            get
+            {
+                yield return new object[] { float.NegativeInfinity, 1.0f, float.NegativeInfinity };
+                yield return new object[] { float.MinValue, 1.0f, float.MinValue };
+                yield return new object[] { -1.0f, 1.0f, 0.0f };
+                yield return new object[] { -MinNormalDouble, 1.0f, 1.0f };
+                yield return new object[] { -MaxSubnormalDouble, 1.0f, 1.0f };
+                yield return new object[] { -float.Epsilon, 1.0f, 1.0f };
+                yield return new object[] { -0.0f, 1.0f, 1.0f };
+                yield return new object[] { float.NaN, 1.0f, float.NaN };
+                yield return new object[] { 0.0f, 1.0f, 1.0f };
+                yield return new object[] { float.Epsilon, 1.0f, 1.0f };
+                yield return new object[] { MaxSubnormalDouble, 1.0f, 1.0f };
+                yield return new object[] { MinNormalDouble, 1.0f, 1.0f };
+                yield return new object[] { 1.0f, 1.0f, 2.0f };
+                yield return new object[] { float.MaxValue, 1.0f, float.MaxValue };
+                yield return new object[] { float.PositiveInfinity, 1.0f, float.PositiveInfinity };
+            }
+        }
+
+        public static IEnumerable<object[]> SubtractSaturateByte => SubtractSaturateUnsignedInteger<byte>();
+        public static IEnumerable<object[]> SubtractSaturateUInt16 => SubtractSaturateUnsignedInteger<ushort>();
+        public static IEnumerable<object[]> SubtractSaturateUInt32 => SubtractSaturateUnsignedInteger<uint>();
+        public static IEnumerable<object[]> SubtractSaturateUInt64 => SubtractSaturateUnsignedInteger<ulong>();
+
+        private static IEnumerable<object[]> SubtractSaturateUnsignedInteger<T>() where T : INumber<T>, IMinMaxValue<T>
+        {
+            yield return new object[] { T.Zero, T.Zero, T.Zero };
+            yield return new object[] { T.Zero, T.CreateChecked(10), T.Zero };
+            yield return new object[] { T.Zero, T.MaxValue, T.Zero };
+
+            yield return new object[] { T.CreateChecked(10), T.Zero, T.CreateChecked(10) };
+            yield return new object[] { T.CreateChecked(10), T.CreateChecked(5), T.CreateChecked(5) };
+            yield return new object[] { T.CreateChecked(10), T.MaxValue, T.Zero };
+
+            yield return new object[] { T.MaxValue, T.Zero, T.MaxValue };
+            yield return new object[] { T.MaxValue, T.CreateChecked(10), T.MaxValue - T.CreateChecked(10) };
+            yield return new object[] { T.MaxValue, T.MaxValue, T.Zero };
+
+            yield return new object[] { T.MaxValue - T.CreateChecked(5), T.CreateChecked(10), T.MaxValue - T.CreateChecked(15) };
+        }
+
+        public static IEnumerable<object[]> SubtractSaturateSByte => SubtractSaturateSignedInteger<sbyte>();
+        public static IEnumerable<object[]> SubtractSaturateInt16 => SubtractSaturateSignedInteger<short>();
+        public static IEnumerable<object[]> SubtractSaturateInt32 => SubtractSaturateSignedInteger<int>();
+        public static IEnumerable<object[]> SubtractSaturateInt64 => SubtractSaturateSignedInteger<long>();
+
+        private static IEnumerable<object[]> SubtractSaturateSignedInteger<T>() where T : INumber<T>, IMinMaxValue<T>
+        {
+            yield return new object[] { T.Zero, T.Zero, T.Zero };
+            yield return new object[] { T.Zero, T.CreateChecked(10), T.CreateChecked(-10) };
+            yield return new object[] { T.Zero, T.CreateChecked(-10), T.CreateChecked(10) };
+            yield return new object[] { T.Zero, T.MinValue, T.MaxValue };
+            yield return new object[] { T.Zero, T.MaxValue, -T.MaxValue };
+
+            yield return new object[] { T.CreateChecked(10), T.Zero, T.CreateChecked(10) };
+            yield return new object[] { T.CreateChecked(10), T.CreateChecked(5), T.CreateChecked(5) };
+            yield return new object[] { T.CreateChecked(10), T.CreateChecked(-5), T.CreateChecked(15) };
+            yield return new object[] { T.CreateChecked(10), T.MinValue, T.MaxValue };
+            yield return new object[] { T.CreateChecked(10), T.MaxValue, -(T.MaxValue - T.CreateChecked(10)) };
+            yield return new object[] { T.CreateChecked(10), T.MinValue + T.CreateChecked(5), T.MaxValue };
+
+            yield return new object[] { T.CreateChecked(-10), T.Zero, T.CreateChecked(-10) };
+            yield return new object[] { T.CreateChecked(-10), T.CreateChecked(5), T.CreateChecked(-15) };
+            yield return new object[] { T.CreateChecked(-10), T.CreateChecked(-5), T.CreateChecked(-5) };
+            yield return new object[] { T.CreateChecked(-10), T.MinValue, -(T.MinValue + T.CreateChecked(10)) };
+            yield return new object[] { T.CreateChecked(-10), T.MaxValue, T.MinValue };
+
+            yield return new object[] { T.MinValue, T.Zero, T.MinValue };
+            yield return new object[] { T.MinValue, T.CreateChecked(10), T.MinValue };
+            yield return new object[] { T.MinValue, T.CreateChecked(-10), T.MinValue + T.CreateChecked(10) };
+            yield return new object[] { T.MinValue, T.MinValue, T.Zero };
+            yield return new object[] { T.MinValue, T.MaxValue, T.MinValue };
+
+            yield return new object[] { T.MaxValue, T.Zero, T.MaxValue };
+            yield return new object[] { T.MaxValue, T.CreateChecked(10), T.MaxValue - T.CreateChecked(10) };
+            yield return new object[] { T.MaxValue, T.CreateChecked(-10), T.MaxValue };
+            yield return new object[] { T.MaxValue, T.MinValue, T.MaxValue };
+            yield return new object[] { T.MaxValue, T.MaxValue, T.Zero };
+
+            yield return new object[] { T.MinValue + T.CreateChecked(5), T.CreateChecked(-10), T.MinValue + T.CreateChecked(15) };
+        }
+
+        public static IEnumerable<object[]> SubtractSaturateDouble
+        {
+            get
+            {
+                yield return new object[] { double.NegativeInfinity, 1.0, double.NegativeInfinity };
+                yield return new object[] { double.MinValue, 1.0, double.MinValue };
+                yield return new object[] { -1.0, 1.0, -2.0 };
+                yield return new object[] { -MinNormalDouble, 1.0, -1.0 };
+                yield return new object[] { -MaxSubnormalDouble, 1.0, -1.0 };
+                yield return new object[] { -double.Epsilon, 1.0, -1.0 };
+                yield return new object[] { -0.0, 1.0, -1.0 };
+                yield return new object[] { double.NaN, 1.0, double.NaN };
+                yield return new object[] { 0.0, 1.0, -1.0 };
+                yield return new object[] { double.Epsilon, 1.0, -1.0 };
+                yield return new object[] { MaxSubnormalDouble, 1.0, -1.0 };
+                yield return new object[] { MinNormalDouble, 1.0, -1.0 };
+                yield return new object[] { 1.0, 1.0, 0.0 };
+                yield return new object[] { double.MaxValue, 1.0, double.MaxValue };
+                yield return new object[] { double.PositiveInfinity, 1.0, double.PositiveInfinity };
+            }
+        }
+
+        public static IEnumerable<object[]> SubtractSaturateSingle
+        {
+            get
+            {
+                yield return new object[] { float.NegativeInfinity, 1.0f, float.NegativeInfinity };
+                yield return new object[] { float.MinValue, 1.0f, float.MinValue };
+                yield return new object[] { -1.0f, 1.0f, -2.0f };
+                yield return new object[] { -MinNormalDouble, 1.0f, -1.0f };
+                yield return new object[] { -MaxSubnormalDouble, 1.0f, -1.0f };
+                yield return new object[] { -float.Epsilon, 1.0f, -1.0f };
+                yield return new object[] { -0.0f, 1.0f, -1.0f };
+                yield return new object[] { float.NaN, 1.0, float.NaN };
+                yield return new object[] { 0.0f, 1.0f, -1.0f };
+                yield return new object[] { float.Epsilon, 1.0f, -1.0f };
+                yield return new object[] { MaxSubnormalDouble, 1.0f, -1.0f };
+                yield return new object[] { MinNormalDouble, 1.0f, -1.0f };
+                yield return new object[] { 1.0f, 1.0f, 0.0f };
+                yield return new object[] { float.MaxValue, 1.0f, float.MaxValue };
+                yield return new object[] { float.PositiveInfinity, 1.0f, float.PositiveInfinity };
+            }
+        }
     }
 }
diff --git a/src/libraries/System.Numerics.Vectors/ref/System.Numerics.Vectors.cs b/src/libraries/System.Numerics.Vectors/ref/System.Numerics.Vectors.cs
index 443d0c64b6f1a0..cca3d7d1f42476 100644
--- a/src/libraries/System.Numerics.Vectors/ref/System.Numerics.Vectors.cs
+++ b/src/libraries/System.Numerics.Vectors/ref/System.Numerics.Vectors.cs
@@ -204,6 +204,7 @@ public static partial class Vector
     {
         public static bool IsHardwareAccelerated { get { throw null; } }
         public static System.Numerics.Vector<T> Abs<T>(System.Numerics.Vector<T> value) { throw null; }
+        public static System.Numerics.Vector<T> AddSaturate<T>(System.Numerics.Vector<T> left, System.Numerics.Vector<T> right) { throw null; }
         public static System.Numerics.Vector<T> Add<T>(System.Numerics.Vector<T> left, System.Numerics.Vector<T> right) { throw null; }
         public static System.Numerics.Vector<T> AndNot<T>(System.Numerics.Vector<T> left, System.Numerics.Vector<T> right) { throw null; }
         public static System.Numerics.Vector<TTo> As<TFrom, TTo>(this System.Numerics.Vector<TFrom> vector) { throw null; }
@@ -420,6 +421,7 @@ public static partial class Vector
         public static void StoreUnsafe<T>(this System.Numerics.Vector<T> source, ref T destination) { throw null; }
         [System.CLSCompliantAttribute(false)]
         public static void StoreUnsafe<T>(this System.Numerics.Vector<T> source, ref T destination, nuint elementOffset) { throw null; }
+        public static System.Numerics.Vector<T> SubtractSaturate<T>(System.Numerics.Vector<T> left, System.Numerics.Vector<T> right) { throw null; }
         public static System.Numerics.Vector<T> Subtract<T>(System.Numerics.Vector<T> left, System.Numerics.Vector<T> right) { throw null; }
         public static T Sum<T>(System.Numerics.Vector<T> value) { throw null; }
         public static T ToScalar<T>(this System.Numerics.Vector<T> vector) { throw null; }
diff --git a/src/libraries/System.Numerics.Vectors/tests/GenericVectorTests.cs b/src/libraries/System.Numerics.Vectors/tests/GenericVectorTests.cs
index 28ed4f701d4693..83502d47ba3f9e 100644
--- a/src/libraries/System.Numerics.Vectors/tests/GenericVectorTests.cs
+++ b/src/libraries/System.Numerics.Vectors/tests/GenericVectorTests.cs
@@ -1141,6 +1141,56 @@ private void TestAdditionOverflow<T>() where T : struct, INumber<T>
                 });
         }
 
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.AddSaturateByte), MemberType = typeof(GenericMathTestMemberData))]
+        public void AddSaturateByte(byte left, byte right, byte expected) => TestAddSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.AddSaturateSByte), MemberType = typeof(GenericMathTestMemberData))]
+        public void AddSaturateSByte(sbyte left, sbyte right, sbyte expected) => TestAddSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.AddSaturateInt16), MemberType = typeof(GenericMathTestMemberData))]
+        public void AddSaturateInt16(short left, short right, short expected) => TestAddSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.AddSaturateUInt16), MemberType = typeof(GenericMathTestMemberData))]
+        public void AddSaturateUInt16(ushort left, ushort right, ushort expected) => TestAddSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.AddSaturateInt32), MemberType = typeof(GenericMathTestMemberData))]
+        public void AddSaturateInt32(int left, int right, int expected) => TestAddSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.AddSaturateUInt32), MemberType = typeof(GenericMathTestMemberData))]
+        public void AddSaturateUInt32(uint left, uint right, uint expected) => TestAddSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.AddSaturateInt64), MemberType = typeof(GenericMathTestMemberData))]
+        public void AddSaturateInt64(long left, long right, long expected) => TestAddSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.AddSaturateUInt64), MemberType = typeof(GenericMathTestMemberData))]
+        public void AddSaturateUInt64(ulong left, ulong right, ulong expected) => TestAddSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.AddSaturateDouble), MemberType = typeof(GenericMathTestMemberData))]
+        public void AddSaturateDouble(double left, double right, double expected) => TestAddSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.AddSaturateSingle), MemberType = typeof(GenericMathTestMemberData))]
+        public void AddSaturateSingle(float left, float right, float expected) => TestAddSaturate(left, right, expected);
+
+        private void TestAddSaturate<T>(T left, T right, T expected) where T : struct, INumber<T>
+        {
+            var actual = Vector.AddSaturate(Vector.Create(left), Vector.Create(right));
+            ValidateVector(actual,
+                (index, val) =>
+                {
+                    Assert.Equal(expected, val);
+                });
+        }
+
         [Fact]
         public void SubtractionByte() { TestSubtraction<byte>(); }
         [Fact]
@@ -1206,6 +1256,56 @@ private void TestSubtractionOverflow<T>() where T : struct, INumber<T>
                 });
         }
 
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.SubtractSaturateByte), MemberType = typeof(GenericMathTestMemberData))]
+        public void SubtractSaturateByte(byte left, byte right, byte expected) => TestSubtractSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.SubtractSaturateSByte), MemberType = typeof(GenericMathTestMemberData))]
+        public void SubtractSaturateSByte(sbyte left, sbyte right, sbyte expected) => TestSubtractSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.SubtractSaturateInt16), MemberType = typeof(GenericMathTestMemberData))]
+        public void SubtractSaturateInt16(short left, short right, short expected) => TestSubtractSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.SubtractSaturateUInt16), MemberType = typeof(GenericMathTestMemberData))]
+        public void SubtractSaturateUInt16(ushort left, ushort right, ushort expected) => TestSubtractSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.SubtractSaturateInt32), MemberType = typeof(GenericMathTestMemberData))]
+        public void SubtractSaturateInt32(int left, int right, int expected) => TestSubtractSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.SubtractSaturateUInt32), MemberType = typeof(GenericMathTestMemberData))]
+        public void SubtractSaturateUInt32(uint left, uint right, uint expected) => TestSubtractSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.SubtractSaturateInt64), MemberType = typeof(GenericMathTestMemberData))]
+        public void SubtractSaturateInt64(long left, long right, long expected) => TestSubtractSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.SubtractSaturateUInt64), MemberType = typeof(GenericMathTestMemberData))]
+        public void SubtractSaturateUInt64(ulong left, ulong right, ulong expected) => TestSubtractSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.SubtractSaturateDouble), MemberType = typeof(GenericMathTestMemberData))]
+        public void SubtractSaturateDouble(double left, double right, double expected) => TestSubtractSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.SubtractSaturateSingle), MemberType = typeof(GenericMathTestMemberData))]
+        public void SubtractSaturateSingle(float left, float right, float expected) => TestSubtractSaturate(left, right, expected);
+
+        private void TestSubtractSaturate<T>(T left, T right, T expected) where T : struct, INumber<T>
+        {
+            var actual = Vector.SubtractSaturate(Vector.Create(left), Vector.Create(right));
+            ValidateVector(actual,
+                (index, val) =>
+                {
+                    Assert.Equal(expected, val);
+                });
+        }
+
         [Fact]
         public void MultiplicationByte() { TestMultiplication<byte>(); }
         [Fact]
diff --git a/src/libraries/System.Private.CoreLib/src/System/Numerics/Vector.cs b/src/libraries/System.Private.CoreLib/src/System/Numerics/Vector.cs
index 821aae27da87f4..f81efbc5720917 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Numerics/Vector.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Numerics/Vector.cs
@@ -5,6 +5,7 @@
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
+using System.Runtime.Intrinsics.Arm;
 using System.Runtime.Intrinsics.X86;
 
 namespace System.Numerics
@@ -62,6 +63,18 @@ public static Vector<T> Abs<T>(Vector<T> value)
         [Intrinsic]
         public static Vector<T> Add<T>(Vector<T> left, Vector<T> right) => left + right;
 
+        /// <summary>Performs saturating addition on two vectors.</summary>
+        /// <param name="left">The vector to add with <paramref name="right" />.</param>
+        /// <param name="right">The vector to add with <paramref name="left" />.</param>
+        /// <typeparam name="T">The type of the elements in the vector.</typeparam>
+        /// <returns>The saturated sum of <paramref name="left" /> and <paramref name="right" />.</returns>
+        [Intrinsic]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Vector<T> AddSaturate<T>(Vector<T> left, Vector<T> right)
+        {
+            return VectorMath.AddSaturate<Vector<T>, T>(left, right);
+        }
+
         /// <summary>Computes the bitwise-and of a given vector and the ones complement of another vector.</summary>
         /// <param name="left">The vector to bitwise-and with <paramref name="right" />.</param>
         /// <param name="right">The vector to that is ones-complemented before being bitwise-and with <paramref name="left" />.</param>
@@ -2647,6 +2660,18 @@ public static void StoreUnsafe<T>(this Vector<T> source, ref T destination, nuin
         [Intrinsic]
         public static Vector<T> Subtract<T>(Vector<T> left, Vector<T> right) => left - right;
 
+        /// <summary>Performs saturating subtraction on two vectors.</summary>
+        /// <param name="left">The vector from which <paramref name="right" /> will be subtracted.</param>
+        /// <param name="right">The vector to subtract from <paramref name="left" />.</param>
+        /// <typeparam name="T">The type of the elements in the vector.</typeparam>
+        /// <returns>The saturated difference of <paramref name="left" /> and <paramref name="right" />.</returns>
+        [Intrinsic]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Vector<T> SubtractSaturate<T>(Vector<T> left, Vector<T> right)
+        {
+            return VectorMath.SubtractSaturate<Vector<T>, T>(left, right);
+        }
+
         /// <summary>
         /// Returns the sum of all elements inside the vector.
         /// </summary>
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector128.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector128.cs
index 8fb3436cf3cf8e..0c68c294880c99 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector128.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector128.cs
@@ -84,6 +84,26 @@ public static Vector128<T> Abs<T>(Vector128<T> vector)
         [Intrinsic]
         public static Vector128<T> Add<T>(Vector128<T> left, Vector128<T> right) => left + right;
 
+        /// <summary>Performs saturating addition on two vectors.</summary>
+        /// <param name="left">The vector to add with <paramref name="right" />.</param>
+        /// <param name="right">The vector to add with <paramref name="left" />.</param>
+        /// <typeparam name="T">The type of the elements in the vector.</typeparam>
+        /// <returns>The saturated sum of <paramref name="left" /> and <paramref name="right" />.</returns>
+        [Intrinsic]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Vector128<T> AddSaturate<T>(Vector128<T> left, Vector128<T> right)
+        {
+            if (IsHardwareAccelerated)
+            {
+                return VectorMath.AddSaturate<Vector128<T>, T>(left, right);
+            }
+
+            return Create(
+                Vector64.AddSaturate(left._lower, right._lower),
+                Vector64.AddSaturate(left._upper, right._upper)
+            );
+        }
+
         /// <summary>Computes the bitwise-and of a given vector and the ones complement of another vector.</summary>
         /// <typeparam name="T">The type of the elements in the vector.</typeparam>
         /// <param name="left">The vector to bitwise-and with <paramref name="right" />.</param>
@@ -3396,6 +3416,26 @@ public static void StoreUnsafe<T>(this Vector128<T> source, ref T destination, n
         [Intrinsic]
         public static Vector128<T> Subtract<T>(Vector128<T> left, Vector128<T> right) => left - right;
 
+        /// <summary>Performs saturating subtraction on two vectors.</summary>
+        /// <param name="left">The vector from which <paramref name="right" /> will be subtracted.</param>
+        /// <param name="right">The vector to subtract from <paramref name="left" />.</param>
+        /// <typeparam name="T">The type of the elements in the vector.</typeparam>
+        /// <returns>The saturated difference of <paramref name="left" /> and <paramref name="right" />.</returns>
+        [Intrinsic]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Vector128<T> SubtractSaturate<T>(Vector128<T> left, Vector128<T> right)
+        {
+            if (IsHardwareAccelerated)
+            {
+                return VectorMath.SubtractSaturate<Vector128<T>, T>(left, right);
+            }
+
+            return Create(
+                Vector64.SubtractSaturate(left._lower, right._lower),
+                Vector64.SubtractSaturate(left._upper, right._upper)
+            );
+        }
+
         /// <summary>Computes the sum of all elements in a vector.</summary>
         /// <typeparam name="T">The type of the elements in the vector.</typeparam>
         /// <param name="vector">The vector whose elements will be summed.</param>
@@ -3895,55 +3935,5 @@ internal static Vector128<byte> UnpackHigh(Vector128<byte> left, Vector128<byte>
             }
             return AdvSimd.Arm64.ZipHigh(left, right);
         }
-
-        // TODO: Make generic versions of these public, see https://github.com/dotnet/runtime/issues/82559
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        [CompExactlyDependsOn(typeof(AdvSimd.Arm64))]
-        [CompExactlyDependsOn(typeof(Sse2))]
-        internal static Vector128<byte> AddSaturate(Vector128<byte> left, Vector128<byte> right)
-        {
-            if (Sse2.IsSupported)
-            {
-                return Sse2.AddSaturate(left, right);
-            }
-            else if (!AdvSimd.Arm64.IsSupported)
-            {
-                ThrowHelper.ThrowNotSupportedException();
-            }
-            return AdvSimd.AddSaturate(left, right);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        [CompExactlyDependsOn(typeof(AdvSimd.Arm64))]
-        [CompExactlyDependsOn(typeof(Sse2))]
-        internal static Vector128<byte> SubtractSaturate(Vector128<byte> left, Vector128<byte> right)
-        {
-            if (Sse2.IsSupported)
-            {
-                return Sse2.SubtractSaturate(left, right);
-            }
-            else if (!AdvSimd.Arm64.IsSupported)
-            {
-                ThrowHelper.ThrowNotSupportedException();
-            }
-            return AdvSimd.SubtractSaturate(left, right);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        [CompExactlyDependsOn(typeof(AdvSimd.Arm64))]
-        [CompExactlyDependsOn(typeof(Sse2))]
-        internal static Vector128<ushort> AddSaturate(Vector128<ushort> left, Vector128<ushort> right)
-        {
-            if (Sse2.IsSupported)
-            {
-                return Sse2.AddSaturate(left, right);
-            }
-            else if (!AdvSimd.Arm64.IsSupported)
-            {
-                ThrowHelper.ThrowNotSupportedException();
-            }
-            return AdvSimd.AddSaturate(left, right);
-        }
     }
 }
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector256.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector256.cs
index 6708b81a203610..c8c707ae8fd7cc 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector256.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector256.cs
@@ -88,6 +88,26 @@ public static Vector256<T> Abs<T>(Vector256<T> vector)
         [Intrinsic]
         public static Vector256<T> Add<T>(Vector256<T> left, Vector256<T> right) => left + right;
 
+        /// <summary>Performs saturating addition on two vectors.</summary>
+        /// <param name="left">The vector to add with <paramref name="right" />.</param>
+        /// <param name="right">The vector to add with <paramref name="left" />.</param>
+        /// <typeparam name="T">The type of the elements in the vector.</typeparam>
+        /// <returns>The saturated sum of <paramref name="left" /> and <paramref name="right" />.</returns>
+        [Intrinsic]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Vector256<T> AddSaturate<T>(Vector256<T> left, Vector256<T> right)
+        {
+            if (IsHardwareAccelerated)
+            {
+                return VectorMath.AddSaturate<Vector256<T>, T>(left, right);
+            }
+
+            return Create(
+                Vector128.AddSaturate(left._lower, right._lower),
+                Vector128.AddSaturate(left._upper, right._upper)
+            );
+        }
+
         /// <summary>Computes the bitwise-and of a given vector and the ones complement of another vector.</summary>
         /// <typeparam name="T">The type of the elements in the vector.</typeparam>
         /// <param name="left">The vector to bitwise-and with <paramref name="right" />.</param>
@@ -3263,6 +3283,26 @@ public static void StoreUnsafe<T>(this Vector256<T> source, ref T destination, n
         [Intrinsic]
         public static Vector256<T> Subtract<T>(Vector256<T> left, Vector256<T> right) => left - right;
 
+        /// <summary>Performs saturating subtraction on two vectors.</summary>
+        /// <param name="left">The vector from which <paramref name="right" /> will be subtracted.</param>
+        /// <param name="right">The vector to subtract from <paramref name="left" />.</param>
+        /// <typeparam name="T">The type of the elements in the vector.</typeparam>
+        /// <returns>The saturated difference of <paramref name="left" /> and <paramref name="right" />.</returns>
+        [Intrinsic]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Vector256<T> SubtractSaturate<T>(Vector256<T> left, Vector256<T> right)
+        {
+            if (IsHardwareAccelerated)
+            {
+                return VectorMath.SubtractSaturate<Vector256<T>, T>(left, right);
+            }
+
+            return Create(
+                Vector128.SubtractSaturate(left._lower, right._lower),
+                Vector128.SubtractSaturate(left._upper, right._upper)
+            );
+        }
+
         /// <summary>Computes the sum of all elements in a vector.</summary>
         /// <param name="vector">The vector whose elements will be summed.</param>
         /// <typeparam name="T">The type of the elements in the vector.</typeparam>
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector512.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector512.cs
index 2b683f06524f45..8324a6c42bc21b 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector512.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector512.cs
@@ -88,6 +88,26 @@ public static Vector512<T> Abs<T>(Vector512<T> vector)
         [Intrinsic]
         public static Vector512<T> Add<T>(Vector512<T> left, Vector512<T> right) => left + right;
 
+        /// <summary>Performs saturating addition on two vectors.</summary>
+        /// <param name="left">The vector to add with <paramref name="right" />.</param>
+        /// <param name="right">The vector to add with <paramref name="left" />.</param>
+        /// <typeparam name="T">The type of the elements in the vector.</typeparam>
+        /// <returns>The saturated sum of <paramref name="left" /> and <paramref name="right" />.</returns>
+        [Intrinsic]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Vector512<T> AddSaturate<T>(Vector512<T> left, Vector512<T> right)
+        {
+            if (IsHardwareAccelerated)
+            {
+                return VectorMath.AddSaturate<Vector512<T>, T>(left, right);
+            }
+
+            return Create(
+                Vector256.AddSaturate(left._lower, right._upper),
+                Vector256.AddSaturate(left._upper, right._upper)
+            );
+        }
+
         /// <summary>Computes the bitwise-and of a given vector and the ones complement of another vector.</summary>
         /// <typeparam name="T">The type of the elements in the vector.</typeparam>
         /// <param name="left">The vector to bitwise-and with <paramref name="right" />.</param>
@@ -3290,6 +3310,26 @@ public static void StoreUnsafe<T>(this Vector512<T> source, ref T destination, n
         [Intrinsic]
         public static Vector512<T> Subtract<T>(Vector512<T> left, Vector512<T> right) => left - right;
 
+        /// <summary>Performs saturating subtraction on two vectors.</summary>
+        /// <param name="left">The vector from which <paramref name="right" /> will be subtracted.</param>
+        /// <param name="right">The vector to subtract from <paramref name="left" />.</param>
+        /// <typeparam name="T">The type of the elements in the vector.</typeparam>
+        /// <returns>The saturated difference of <paramref name="left" /> and <paramref name="right" />.</returns>
+        [Intrinsic]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Vector512<T> SubtractSaturate<T>(Vector512<T> left, Vector512<T> right)
+        {
+            if (IsHardwareAccelerated)
+            {
+                return VectorMath.SubtractSaturate<Vector512<T>, T>(left, right);
+            }
+
+            return Create(
+                Vector256.SubtractSaturate(left._lower, right._upper),
+                Vector256.SubtractSaturate(left._upper, right._upper)
+            );
+        }
+
         /// <summary>Computes the sum of all elements in a vector.</summary>
         /// <param name="vector">The vector whose elements will be summed.</param>
         /// <typeparam name="T">The type of the elements in the vector.</typeparam>
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector64.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector64.cs
index 570933c7abbba2..cf21a167a8629e 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector64.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector64.cs
@@ -67,6 +67,18 @@ public static Vector64<T> Abs<T>(Vector64<T> vector)
         [Intrinsic]
         public static Vector64<T> Add<T>(Vector64<T> left, Vector64<T> right) => left + right;
 
+        /// <summary>Performs saturating addition on two vectors.</summary>
+        /// <param name="left">The vector to add with <paramref name="right" />.</param>
+        /// <param name="right">The vector to add with <paramref name="left" />.</param>
+        /// <typeparam name="T">The type of the elements in the vector.</typeparam>
+        /// <returns>The saturated sum of <paramref name="left" /> and <paramref name="right" />.</returns>
+        [Intrinsic]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Vector64<T> AddSaturate<T>(Vector64<T> left, Vector64<T> right)
+        {
+            return VectorMath.AddSaturate<Vector64<T>, T>(left, right);
+        }
+
         /// <summary>Computes the bitwise-and of a given vector and the ones complement of another vector.</summary>
         /// <typeparam name="T">The type of the elements in the vector.</typeparam>
         /// <param name="left">The vector to bitwise-and with <paramref name="right" />.</param>
@@ -3275,6 +3287,18 @@ public static void StoreUnsafe<T>(this Vector64<T> source, ref T destination, nu
         [Intrinsic]
         public static Vector64<T> Subtract<T>(Vector64<T> left, Vector64<T> right) => left - right;
 
+        /// <summary>Performs saturating subtraction on two vectors.</summary>
+        /// <param name="left">The vector from which <paramref name="right" /> will be subtracted.</param>
+        /// <param name="right">The vector to subtract from <paramref name="left" />.</param>
+        /// <typeparam name="T">The type of the elements in the vector.</typeparam>
+        /// <returns>The saturated difference of <paramref name="left" /> and <paramref name="right" />.</returns>
+        [Intrinsic]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Vector64<T> SubtractSaturate<T>(Vector64<T> left, Vector64<T> right)
+        {
+            return VectorMath.SubtractSaturate<Vector64<T>, T>(left, right);
+        }
+
         /// <summary>Computes the sum of all elements in a vector.</summary>
         /// <typeparam name="T">The type of the elements in the vector.</typeparam>
         /// <param name="vector">The vector whose elements will be summed.</param>
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/VectorMath.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/VectorMath.cs
index fbd5af0fa1b783..30382388b068c0 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/VectorMath.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/VectorMath.cs
@@ -1588,6 +1588,74 @@ public static TVector MinNumber<TVector, T>(TVector x, TVector y)
             return TVector.Min(x, y);
         }
 
+        public static TVector AddSaturate<TVector, T>(TVector left, TVector right)
+            where TVector : unmanaged, ISimdVector<TVector, T>
+        {
+            TVector sum = left + right;
+
+            if ((typeof(T) == typeof(float)) || (typeof(T) == typeof(double)))
+            {
+                return sum;
+            }
+
+            if ((typeof(T) == typeof(byte))
+             || (typeof(T) == typeof(ushort))
+             || (typeof(T) == typeof(uint))
+             || (typeof(T) == typeof(ulong))
+             || (typeof(T) == typeof(nuint)))
+            {
+                // Equivalent to sum < left ? T.MaxValue : sum
+                return TVector.LessThan(sum, left) | sum;
+            }
+
+            Debug.Assert((typeof(T) == typeof(sbyte))
+                      || (typeof(T) == typeof(short))
+                      || (typeof(T) == typeof(int))
+                      || (typeof(T) == typeof(long))
+                      || (typeof(T) == typeof(nint)));
+
+            // Condition is equivalent to: (sign(left) != sign(sum)) && (sign(left) == sign(right))
+            // Overflow result is equivalent to: left < 0 ? T.MinValue : T.MaxValue
+            return TVector.ConditionalSelect(
+                TVector.IsNegative(TVector.AndNot(left ^ sum, left ^ right)),
+                (TVector.AllBitsSet >>> 1) ^ TVector.IsNegative(left),
+                sum);
+        }
+
+        public static TVector SubtractSaturate<TVector, T>(TVector left, TVector right)
+            where TVector : unmanaged, ISimdVector<TVector, T>
+        {
+            TVector diff = left - right;
+
+            if ((typeof(T) == typeof(float)) || (typeof(T) == typeof(double)))
+            {
+                return diff;
+            }
+
+            if ((typeof(T) == typeof(byte))
+             || (typeof(T) == typeof(ushort))
+             || (typeof(T) == typeof(uint))
+             || (typeof(T) == typeof(ulong))
+             || (typeof(T) == typeof(nuint)))
+            {
+                // Equivalent to diff <= left ? diff : 0
+                return TVector.LessThanOrEqual(diff, left) & diff;
+            }
+
+            Debug.Assert((typeof(T) == typeof(sbyte))
+                      || (typeof(T) == typeof(short))
+                      || (typeof(T) == typeof(int))
+                      || (typeof(T) == typeof(long))
+                      || (typeof(T) == typeof(nint)));
+
+            // Condition is equivalent to: (sign(left) != sign(diff)) && (sign(left) != sign(right))
+            // Overflow result is equivalent to: left < 0 ? T.MinValue : T.MaxValue
+            return TVector.ConditionalSelect(
+                TVector.IsNegative((left ^ diff) & (left ^ right)),
+                (TVector.AllBitsSet >>> 1) ^ TVector.IsNegative(left),
+                diff);
+        }
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static TVector RadiansToDegrees<TVector, T>(TVector radians)
             where TVector : unmanaged, ISimdVector<TVector, T>
diff --git a/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs b/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs
index 352820d85007c3..b165802024ccc3 100644
--- a/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs
+++ b/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs
@@ -12,6 +12,7 @@ public static partial class Vector128
     {
         public static bool IsHardwareAccelerated { get { throw null; } }
         public static System.Runtime.Intrinsics.Vector128<T> Abs<T>(System.Runtime.Intrinsics.Vector128<T> vector) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<T> AddSaturate<T>(System.Runtime.Intrinsics.Vector128<T> left, System.Runtime.Intrinsics.Vector128<T> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<T> Add<T>(System.Runtime.Intrinsics.Vector128<T> left, System.Runtime.Intrinsics.Vector128<T> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<T> AndNot<T>(System.Runtime.Intrinsics.Vector128<T> left, System.Runtime.Intrinsics.Vector128<T> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<System.Byte> AsByte<T>(this System.Runtime.Intrinsics.Vector128<T> vector) { throw null; }
@@ -315,6 +316,7 @@ public static void CopyTo<T>(this System.Runtime.Intrinsics.Vector128<T> vector,
         public static void StoreUnsafe<T>(this System.Runtime.Intrinsics.Vector128<T> source, ref T destination) { throw null; }
         [System.CLSCompliantAttribute(false)]
         public static void StoreUnsafe<T>(this System.Runtime.Intrinsics.Vector128<T> source, ref T destination, nuint elementOffset) { throw null; }
+        public static System.Runtime.Intrinsics.Vector128<T> SubtractSaturate<T>(System.Runtime.Intrinsics.Vector128<T> left, System.Runtime.Intrinsics.Vector128<T> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector128<T> Subtract<T>(System.Runtime.Intrinsics.Vector128<T> left, System.Runtime.Intrinsics.Vector128<T> right) { throw null; }
         public static T Sum<T>(System.Runtime.Intrinsics.Vector128<T> vector) { throw null; }
         public static T ToScalar<T>(this System.Runtime.Intrinsics.Vector128<T> vector) { throw null; }
@@ -398,6 +400,7 @@ public static partial class Vector256
     {
         public static bool IsHardwareAccelerated { get { throw null; } }
         public static System.Runtime.Intrinsics.Vector256<T> Abs<T>(System.Runtime.Intrinsics.Vector256<T> vector) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<T> AddSaturate<T>(System.Runtime.Intrinsics.Vector256<T> left, System.Runtime.Intrinsics.Vector256<T> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<T> Add<T>(System.Runtime.Intrinsics.Vector256<T> left, System.Runtime.Intrinsics.Vector256<T> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<T> AndNot<T>(System.Runtime.Intrinsics.Vector256<T> left, System.Runtime.Intrinsics.Vector256<T> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<System.Byte> AsByte<T>(this System.Runtime.Intrinsics.Vector256<T> vector) { throw null; }
@@ -694,6 +697,7 @@ public static void CopyTo<T>(this System.Runtime.Intrinsics.Vector256<T> vector,
         public static void StoreUnsafe<T>(this System.Runtime.Intrinsics.Vector256<T> source, ref T destination) { throw null; }
         [System.CLSCompliantAttribute(false)]
         public static void StoreUnsafe<T>(this System.Runtime.Intrinsics.Vector256<T> source, ref T destination, nuint elementOffset) { throw null; }
+        public static System.Runtime.Intrinsics.Vector256<T> SubtractSaturate<T>(System.Runtime.Intrinsics.Vector256<T> left, System.Runtime.Intrinsics.Vector256<T> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector256<T> Subtract<T>(System.Runtime.Intrinsics.Vector256<T> left, System.Runtime.Intrinsics.Vector256<T> right) { throw null; }
         public static T Sum<T>(System.Runtime.Intrinsics.Vector256<T> vector) { throw null; }
         public static T ToScalar<T>(this System.Runtime.Intrinsics.Vector256<T> vector) { throw null; }
@@ -777,6 +781,7 @@ public static partial class Vector512
     {
         public static bool IsHardwareAccelerated { get { throw null; } }
         public static System.Runtime.Intrinsics.Vector512<T> Abs<T>(System.Runtime.Intrinsics.Vector512<T> vector) { throw null; }
+        public static System.Runtime.Intrinsics.Vector512<T> AddSaturate<T>(System.Runtime.Intrinsics.Vector512<T> left, System.Runtime.Intrinsics.Vector512<T> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector512<T> Add<T>(System.Runtime.Intrinsics.Vector512<T> left, System.Runtime.Intrinsics.Vector512<T> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector512<T> AndNot<T>(System.Runtime.Intrinsics.Vector512<T> left, System.Runtime.Intrinsics.Vector512<T> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector512<System.Byte> AsByte<T>(this System.Runtime.Intrinsics.Vector512<T> vector) { throw null; }
@@ -1074,6 +1079,7 @@ public static void CopyTo<T>(this System.Runtime.Intrinsics.Vector512<T> vector,
         public static void StoreUnsafe<T>(this System.Runtime.Intrinsics.Vector512<T> source, ref T destination) { throw null; }
         [System.CLSCompliantAttribute(false)]
         public static void StoreUnsafe<T>(this System.Runtime.Intrinsics.Vector512<T> source, ref T destination, nuint elementOffset) { throw null; }
+        public static System.Runtime.Intrinsics.Vector512<T> SubtractSaturate<T>(System.Runtime.Intrinsics.Vector512<T> left, System.Runtime.Intrinsics.Vector512<T> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector512<T> Subtract<T>(System.Runtime.Intrinsics.Vector512<T> left, System.Runtime.Intrinsics.Vector512<T> right) { throw null; }
         public static T Sum<T>(System.Runtime.Intrinsics.Vector512<T> vector) { throw null; }
         public static T ToScalar<T>(this System.Runtime.Intrinsics.Vector512<T> vector) { throw null; }
@@ -1155,6 +1161,7 @@ public static partial class Vector64
     {
         public static bool IsHardwareAccelerated { get { throw null; } }
         public static System.Runtime.Intrinsics.Vector64<T> Abs<T>(System.Runtime.Intrinsics.Vector64<T> vector) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<T> AddSaturate<T>(System.Runtime.Intrinsics.Vector64<T> left, System.Runtime.Intrinsics.Vector64<T> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector64<T> Add<T>(System.Runtime.Intrinsics.Vector64<T> left, System.Runtime.Intrinsics.Vector64<T> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector64<T> AndNot<T>(System.Runtime.Intrinsics.Vector64<T> left, System.Runtime.Intrinsics.Vector64<T> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector64<System.Byte> AsByte<T>(this System.Runtime.Intrinsics.Vector64<T> vector) { throw null; }
@@ -1419,6 +1426,7 @@ public static void CopyTo<T>(this System.Runtime.Intrinsics.Vector64<T> vector,
         public static void StoreUnsafe<T>(this System.Runtime.Intrinsics.Vector64<T> source, ref T destination) { throw null; }
         [System.CLSCompliantAttribute(false)]
         public static void StoreUnsafe<T>(this System.Runtime.Intrinsics.Vector64<T> source, ref T destination, nuint elementOffset) { throw null; }
+        public static System.Runtime.Intrinsics.Vector64<T> SubtractSaturate<T>(System.Runtime.Intrinsics.Vector64<T> left, System.Runtime.Intrinsics.Vector64<T> right) { throw null; }
         public static System.Runtime.Intrinsics.Vector64<T> Subtract<T>(System.Runtime.Intrinsics.Vector64<T> left, System.Runtime.Intrinsics.Vector64<T> right) { throw null; }
         public static T Sum<T>(System.Runtime.Intrinsics.Vector64<T> vector) { throw null; }
         public static T ToScalar<T>(this System.Runtime.Intrinsics.Vector64<T> vector) { throw null; }
diff --git a/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector128Tests.cs b/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector128Tests.cs
index 09153068d91439..a1fefbc79c6093 100644
--- a/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector128Tests.cs
+++ b/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector128Tests.cs
@@ -5393,5 +5393,97 @@ public void TruncateSingleTest(float value, float expectedResult)
             Vector128<float> actualResult = Vector128.Truncate(Vector128.Create(value));
             AssertEqual(Vector128.Create(expectedResult), actualResult, Vector128<float>.Zero);
         }
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.AddSaturateByte), MemberType = typeof(GenericMathTestMemberData))]
+        public void AddSaturateByte(byte left, byte right, byte expected) => TestAddSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.AddSaturateSByte), MemberType = typeof(GenericMathTestMemberData))]
+        public void AddSaturateSByte(sbyte left, sbyte right, sbyte expected) => TestAddSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.AddSaturateInt16), MemberType = typeof(GenericMathTestMemberData))]
+        public void AddSaturateInt16(short left, short right, short expected) => TestAddSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.AddSaturateUInt16), MemberType = typeof(GenericMathTestMemberData))]
+        public void AddSaturateUInt16(ushort left, ushort right, ushort expected) => TestAddSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.AddSaturateInt32), MemberType = typeof(GenericMathTestMemberData))]
+        public void AddSaturateInt32(int left, int right, int expected) => TestAddSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.AddSaturateUInt32), MemberType = typeof(GenericMathTestMemberData))]
+        public void AddSaturateUInt32(uint left, uint right, uint expected) => TestAddSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.AddSaturateInt64), MemberType = typeof(GenericMathTestMemberData))]
+        public void AddSaturateInt64(long left, long right, long expected) => TestAddSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.AddSaturateUInt64), MemberType = typeof(GenericMathTestMemberData))]
+        public void AddSaturateUInt64(ulong left, ulong right, ulong expected) => TestAddSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.AddSaturateDouble), MemberType = typeof(GenericMathTestMemberData))]
+        public void AddSaturateDouble(double left, double right, double expected) => TestAddSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.AddSaturateSingle), MemberType = typeof(GenericMathTestMemberData))]
+        public void AddSaturateSingle(float left, float right, float expected) => TestAddSaturate(left, right, expected);
+
+        private void TestAddSaturate<T>(T left, T right, T expected)
+        {
+            Vector128<T> actualResult = Vector128.AddSaturate(Vector128.Create(left), Vector128.Create(right));
+            Assert.Equal(Vector128.Create(expected), actualResult);
+        }
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.SubtractSaturateByte), MemberType = typeof(GenericMathTestMemberData))]
+        public void SubtractSaturateByte(byte left, byte right, byte expected) => TestSubtractSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.SubtractSaturateSByte), MemberType = typeof(GenericMathTestMemberData))]
+        public void SubtractSaturateSByte(sbyte left, sbyte right, sbyte expected) => TestSubtractSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.SubtractSaturateInt16), MemberType = typeof(GenericMathTestMemberData))]
+        public void SubtractSaturateInt16(short left, short right, short expected) => TestSubtractSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.SubtractSaturateUInt16), MemberType = typeof(GenericMathTestMemberData))]
+        public void SubtractSaturateUInt16(ushort left, ushort right, ushort expected) => TestSubtractSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.SubtractSaturateInt32), MemberType = typeof(GenericMathTestMemberData))]
+        public void SubtractSaturateInt32(int left, int right, int expected) => TestSubtractSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.SubtractSaturateUInt32), MemberType = typeof(GenericMathTestMemberData))]
+        public void SubtractSaturateUInt32(uint left, uint right, uint expected) => TestSubtractSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.SubtractSaturateInt64), MemberType = typeof(GenericMathTestMemberData))]
+        public void SubtractSaturateInt64(long left, long right, long expected) => TestSubtractSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.SubtractSaturateUInt64), MemberType = typeof(GenericMathTestMemberData))]
+        public void SubtractSaturateUInt64(ulong left, ulong right, ulong expected) => TestSubtractSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.SubtractSaturateDouble), MemberType = typeof(GenericMathTestMemberData))]
+        public void SubtractSaturateDouble(double left, double right, double expected) => TestSubtractSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.SubtractSaturateSingle), MemberType = typeof(GenericMathTestMemberData))]
+        public void SubtractSaturateSingle(float left, float right, float expected) => TestSubtractSaturate(left, right, expected);
+
+        private void TestSubtractSaturate<T>(T left, T right, T expected)
+        {
+            Vector128<T> actualResult = Vector128.SubtractSaturate(Vector128.Create(left), Vector128.Create(right));
+            Assert.Equal(Vector128.Create(expected), actualResult);
+        }
     }
 }
diff --git a/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector256Tests.cs b/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector256Tests.cs
index d16e5eed481809..e23db25c4aa094 100644
--- a/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector256Tests.cs
+++ b/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector256Tests.cs
@@ -6410,5 +6410,97 @@ public void TruncateSingleTest(float value, float expectedResult)
             Vector256<float> actualResult = Vector256.Truncate(Vector256.Create(value));
             AssertEqual(Vector256.Create(expectedResult), actualResult, Vector256<float>.Zero);
         }
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.AddSaturateByte), MemberType = typeof(GenericMathTestMemberData))]
+        public void AddSaturateByte(byte left, byte right, byte expected) => TestAddSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.AddSaturateSByte), MemberType = typeof(GenericMathTestMemberData))]
+        public void AddSaturateSByte(sbyte left, sbyte right, sbyte expected) => TestAddSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.AddSaturateInt16), MemberType = typeof(GenericMathTestMemberData))]
+        public void AddSaturateInt16(short left, short right, short expected) => TestAddSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.AddSaturateUInt16), MemberType = typeof(GenericMathTestMemberData))]
+        public void AddSaturateUInt16(ushort left, ushort right, ushort expected) => TestAddSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.AddSaturateInt32), MemberType = typeof(GenericMathTestMemberData))]
+        public void AddSaturateInt32(int left, int right, int expected) => TestAddSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.AddSaturateUInt32), MemberType = typeof(GenericMathTestMemberData))]
+        public void AddSaturateUInt32(uint left, uint right, uint expected) => TestAddSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.AddSaturateInt64), MemberType = typeof(GenericMathTestMemberData))]
+        public void AddSaturateInt64(long left, long right, long expected) => TestAddSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.AddSaturateUInt64), MemberType = typeof(GenericMathTestMemberData))]
+        public void AddSaturateUInt64(ulong left, ulong right, ulong expected) => TestAddSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.AddSaturateDouble), MemberType = typeof(GenericMathTestMemberData))]
+        public void AddSaturateDouble(double left, double right, double expected) => TestAddSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.AddSaturateSingle), MemberType = typeof(GenericMathTestMemberData))]
+        public void AddSaturateSingle(float left, float right, float expected) => TestAddSaturate(left, right, expected);
+
+        private void TestAddSaturate<T>(T left, T right, T expected)
+        {
+            Vector256<T> actualResult = Vector256.AddSaturate(Vector256.Create(left), Vector256.Create(right));
+            Assert.Equal(Vector256.Create(expected), actualResult);
+        }
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.SubtractSaturateByte), MemberType = typeof(GenericMathTestMemberData))]
+        public void SubtractSaturateByte(byte left, byte right, byte expected) => TestSubtractSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.SubtractSaturateSByte), MemberType = typeof(GenericMathTestMemberData))]
+        public void SubtractSaturateSByte(sbyte left, sbyte right, sbyte expected) => TestSubtractSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.SubtractSaturateInt16), MemberType = typeof(GenericMathTestMemberData))]
+        public void SubtractSaturateInt16(short left, short right, short expected) => TestSubtractSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.SubtractSaturateUInt16), MemberType = typeof(GenericMathTestMemberData))]
+        public void SubtractSaturateUInt16(ushort left, ushort right, ushort expected) => TestSubtractSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.SubtractSaturateInt32), MemberType = typeof(GenericMathTestMemberData))]
+        public void SubtractSaturateInt32(int left, int right, int expected) => TestSubtractSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.SubtractSaturateUInt32), MemberType = typeof(GenericMathTestMemberData))]
+        public void SubtractSaturateUInt32(uint left, uint right, uint expected) => TestSubtractSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.SubtractSaturateInt64), MemberType = typeof(GenericMathTestMemberData))]
+        public void SubtractSaturateInt64(long left, long right, long expected) => TestSubtractSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.SubtractSaturateUInt64), MemberType = typeof(GenericMathTestMemberData))]
+        public void SubtractSaturateUInt64(ulong left, ulong right, ulong expected) => TestSubtractSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.SubtractSaturateDouble), MemberType = typeof(GenericMathTestMemberData))]
+        public void SubtractSaturateDouble(double left, double right, double expected) => TestSubtractSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.SubtractSaturateSingle), MemberType = typeof(GenericMathTestMemberData))]
+        public void SubtractSaturateSingle(float left, float right, float expected) => TestSubtractSaturate(left, right, expected);
+
+        private void TestSubtractSaturate<T>(T left, T right, T expected)
+        {
+            Vector256<T> actualResult = Vector256.SubtractSaturate(Vector256.Create(left), Vector256.Create(right));
+            Assert.Equal(Vector256.Create(expected), actualResult);
+        }
     }
 }
diff --git a/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector512Tests.cs b/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector512Tests.cs
index f996d82369615f..bc1a628df15ca5 100644
--- a/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector512Tests.cs
+++ b/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector512Tests.cs
@@ -5843,5 +5843,97 @@ public void TruncateSingleTest(float value, float expectedResult)
             Vector512<float> actualResult = Vector512.Truncate(Vector512.Create(value));
             AssertEqual(Vector512.Create(expectedResult), actualResult, Vector512<float>.Zero);
         }
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.AddSaturateByte), MemberType = typeof(GenericMathTestMemberData))]
+        public void AddSaturateByte(byte left, byte right, byte expected) => TestAddSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.AddSaturateSByte), MemberType = typeof(GenericMathTestMemberData))]
+        public void AddSaturateSByte(sbyte left, sbyte right, sbyte expected) => TestAddSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.AddSaturateInt16), MemberType = typeof(GenericMathTestMemberData))]
+        public void AddSaturateInt16(short left, short right, short expected) => TestAddSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.AddSaturateUInt16), MemberType = typeof(GenericMathTestMemberData))]
+        public void AddSaturateUInt16(ushort left, ushort right, ushort expected) => TestAddSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.AddSaturateInt32), MemberType = typeof(GenericMathTestMemberData))]
+        public void AddSaturateInt32(int left, int right, int expected) => TestAddSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.AddSaturateUInt32), MemberType = typeof(GenericMathTestMemberData))]
+        public void AddSaturateUInt32(uint left, uint right, uint expected) => TestAddSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.AddSaturateInt64), MemberType = typeof(GenericMathTestMemberData))]
+        public void AddSaturateInt64(long left, long right, long expected) => TestAddSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.AddSaturateUInt64), MemberType = typeof(GenericMathTestMemberData))]
+        public void AddSaturateUInt64(ulong left, ulong right, ulong expected) => TestAddSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.AddSaturateDouble), MemberType = typeof(GenericMathTestMemberData))]
+        public void AddSaturateDouble(double left, double right, double expected) => TestAddSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.AddSaturateSingle), MemberType = typeof(GenericMathTestMemberData))]
+        public void AddSaturateSingle(float left, float right, float expected) => TestAddSaturate(left, right, expected);
+
+        private void TestAddSaturate<T>(T left, T right, T expected)
+        {
+            Vector512<T> actualResult = Vector512.AddSaturate(Vector512.Create(left), Vector512.Create(right));
+            Assert.Equal(Vector512.Create(expected), actualResult);
+        }
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.SubtractSaturateByte), MemberType = typeof(GenericMathTestMemberData))]
+        public void SubtractSaturateByte(byte left, byte right, byte expected) => TestSubtractSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.SubtractSaturateSByte), MemberType = typeof(GenericMathTestMemberData))]
+        public void SubtractSaturateSByte(sbyte left, sbyte right, sbyte expected) => TestSubtractSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.SubtractSaturateInt16), MemberType = typeof(GenericMathTestMemberData))]
+        public void SubtractSaturateInt16(short left, short right, short expected) => TestSubtractSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.SubtractSaturateUInt16), MemberType = typeof(GenericMathTestMemberData))]
+        public void SubtractSaturateUInt16(ushort left, ushort right, ushort expected) => TestSubtractSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.SubtractSaturateInt32), MemberType = typeof(GenericMathTestMemberData))]
+        public void SubtractSaturateInt32(int left, int right, int expected) => TestSubtractSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.SubtractSaturateUInt32), MemberType = typeof(GenericMathTestMemberData))]
+        public void SubtractSaturateUInt32(uint left, uint right, uint expected) => TestSubtractSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.SubtractSaturateInt64), MemberType = typeof(GenericMathTestMemberData))]
+        public void SubtractSaturateInt64(long left, long right, long expected) => TestSubtractSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.SubtractSaturateUInt64), MemberType = typeof(GenericMathTestMemberData))]
+        public void SubtractSaturateUInt64(ulong left, ulong right, ulong expected) => TestSubtractSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.SubtractSaturateDouble), MemberType = typeof(GenericMathTestMemberData))]
+        public void SubtractSaturateDouble(double left, double right, double expected) => TestSubtractSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.SubtractSaturateSingle), MemberType = typeof(GenericMathTestMemberData))]
+        public void SubtractSaturateSingle(float left, float right, float expected) => TestSubtractSaturate(left, right, expected);
+
+        private void TestSubtractSaturate<T>(T left, T right, T expected)
+        {
+            Vector512<T> actualResult = Vector512.SubtractSaturate(Vector512.Create(left), Vector512.Create(right));
+            Assert.Equal(Vector512.Create(expected), actualResult);
+        }
     }
 }
diff --git a/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector64Tests.cs b/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector64Tests.cs
index c049c08515a083..cebc07750fc222 100644
--- a/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector64Tests.cs
+++ b/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector64Tests.cs
@@ -4801,5 +4801,97 @@ public void TruncateSingleTest(float value, float expectedResult)
             Vector64<float> actualResult = Vector64.Truncate(Vector64.Create(value));
             AssertEqual(Vector64.Create(expectedResult), actualResult, Vector64<float>.Zero);
         }
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.AddSaturateByte), MemberType = typeof(GenericMathTestMemberData))]
+        public void AddSaturateByte(byte left, byte right, byte expected) => TestAddSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.AddSaturateSByte), MemberType = typeof(GenericMathTestMemberData))]
+        public void AddSaturateSByte(sbyte left, sbyte right, sbyte expected) => TestAddSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.AddSaturateInt16), MemberType = typeof(GenericMathTestMemberData))]
+        public void AddSaturateInt16(short left, short right, short expected) => TestAddSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.AddSaturateUInt16), MemberType = typeof(GenericMathTestMemberData))]
+        public void AddSaturateUInt16(ushort left, ushort right, ushort expected) => TestAddSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.AddSaturateInt32), MemberType = typeof(GenericMathTestMemberData))]
+        public void AddSaturateInt32(int left, int right, int expected) => TestAddSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.AddSaturateUInt32), MemberType = typeof(GenericMathTestMemberData))]
+        public void AddSaturateUInt32(uint left, uint right, uint expected) => TestAddSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.AddSaturateInt64), MemberType = typeof(GenericMathTestMemberData))]
+        public void AddSaturateInt64(long left, long right, long expected) => TestAddSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.AddSaturateUInt64), MemberType = typeof(GenericMathTestMemberData))]
+        public void AddSaturateUInt64(ulong left, ulong right, ulong expected) => TestAddSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.AddSaturateDouble), MemberType = typeof(GenericMathTestMemberData))]
+        public void AddSaturateDouble(double left, double right, double expected) => TestAddSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.AddSaturateSingle), MemberType = typeof(GenericMathTestMemberData))]
+        public void AddSaturateSingle(float left, float right, float expected) => TestAddSaturate(left, right, expected);
+
+        private void TestAddSaturate<T>(T left, T right, T expected)
+        {
+            Vector64<T> actualResult = Vector64.AddSaturate(Vector64.Create(left), Vector64.Create(right));
+            Assert.Equal(Vector64.Create(expected), actualResult);
+        }
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.SubtractSaturateByte), MemberType = typeof(GenericMathTestMemberData))]
+        public void SubtractSaturateByte(byte left, byte right, byte expected) => TestSubtractSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.SubtractSaturateSByte), MemberType = typeof(GenericMathTestMemberData))]
+        public void SubtractSaturateSByte(sbyte left, sbyte right, sbyte expected) => TestSubtractSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.SubtractSaturateInt16), MemberType = typeof(GenericMathTestMemberData))]
+        public void SubtractSaturateInt16(short left, short right, short expected) => TestSubtractSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.SubtractSaturateUInt16), MemberType = typeof(GenericMathTestMemberData))]
+        public void SubtractSaturateUInt16(ushort left, ushort right, ushort expected) => TestSubtractSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.SubtractSaturateInt32), MemberType = typeof(GenericMathTestMemberData))]
+        public void SubtractSaturateInt32(int left, int right, int expected) => TestSubtractSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.SubtractSaturateUInt32), MemberType = typeof(GenericMathTestMemberData))]
+        public void SubtractSaturateUInt32(uint left, uint right, uint expected) => TestSubtractSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.SubtractSaturateInt64), MemberType = typeof(GenericMathTestMemberData))]
+        public void SubtractSaturateInt64(long left, long right, long expected) => TestSubtractSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.SubtractSaturateUInt64), MemberType = typeof(GenericMathTestMemberData))]
+        public void SubtractSaturateUInt64(ulong left, ulong right, ulong expected) => TestSubtractSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.SubtractSaturateDouble), MemberType = typeof(GenericMathTestMemberData))]
+        public void SubtractSaturateDouble(double left, double right, double expected) => TestSubtractSaturate(left, right, expected);
+
+        [Theory]
+        [MemberData(nameof(GenericMathTestMemberData.SubtractSaturateSingle), MemberType = typeof(GenericMathTestMemberData))]
+        public void SubtractSaturateSingle(float left, float right, float expected) => TestSubtractSaturate(left, right, expected);
+
+        private void TestSubtractSaturate<T>(T left, T right, T expected)
+        {
+            Vector64<T> actualResult = Vector64.SubtractSaturate(Vector64.Create(left), Vector64.Create(right));
+            Assert.Equal(Vector64.Create(expected), actualResult);
+        }
     }
 }