diff --git a/doc/source/reference/c-api/array.rst b/doc/source/reference/c-api/array.rst
index 02db78ebb2b1..076c27bdad08 100644
--- a/doc/source/reference/c-api/array.rst
+++ b/doc/source/reference/c-api/array.rst
@@ -4452,5 +4452,10 @@ Enumerated Types
 
        Allow any cast, no matter what kind of data loss may occur.
 
+    .. c:enumerator:: NPY_SAME_VALUE_CASTING
+
+       Allow any cast, but error if any values change during the cast. Currently
+       supported only in ``ndarray.astype(... casting='same_value')``
+
 .. index::
    pair: ndarray; C-API
diff --git a/numpy/__init__.cython-30.pxd b/numpy/__init__.cython-30.pxd
index 86c91cf617a5..c71898626070 100644
--- a/numpy/__init__.cython-30.pxd
+++ b/numpy/__init__.cython-30.pxd
@@ -156,6 +156,7 @@ cdef extern from "numpy/arrayobject.h":
         NPY_SAFE_CASTING
         NPY_SAME_KIND_CASTING
         NPY_UNSAFE_CASTING
+        NPY_SAME_VALUE_CASTING
 
     ctypedef enum NPY_CLIPMODE:
         NPY_CLIP
diff --git a/numpy/__init__.pxd b/numpy/__init__.pxd
index eb0764126116..40a24b6c7cc1 100644
--- a/numpy/__init__.pxd
+++ b/numpy/__init__.pxd
@@ -165,6 +165,7 @@ cdef extern from "numpy/arrayobject.h":
         NPY_SAFE_CASTING
         NPY_SAME_KIND_CASTING
         NPY_UNSAFE_CASTING
+        NPY_SAME_VALUE_CASTING
 
     ctypedef enum NPY_CLIPMODE:
         NPY_CLIP
diff --git a/numpy/_core/code_generators/cversions.txt b/numpy/_core/code_generators/cversions.txt
index 0d642d760b21..a04dd784c67f 100644
--- a/numpy/_core/code_generators/cversions.txt
+++ b/numpy/_core/code_generators/cversions.txt
@@ -79,5 +79,6 @@
 # Version 19 (NumPy 2.2.0) No change
 0x00000013 = 2b8f1f4da822491ff030b2b37dff07e3
 # Version 20 (NumPy 2.3.0)
-# Version 20 (NumPy 2.4.0) No change
 0x00000014 = e56b74d32a934d085e7c3414cb9999b8,
+# Version 21 (NumPy 2.4.0) Add 'same_value' casting, header additions
+0x00000015 = e56b74d32a934d085e7c3414cb9999b8,
diff --git a/numpy/_core/include/numpy/dtype_api.h b/numpy/_core/include/numpy/dtype_api.h
index b37c9fbb6821..f902a9a74d19 100644
--- a/numpy/_core/include/numpy/dtype_api.h
+++ b/numpy/_core/include/numpy/dtype_api.h
@@ -107,7 +107,15 @@ typedef struct PyArrayMethod_Context_tag {
 
     /* Operand descriptors, filled in by resolve_descriptors */
     PyArray_Descr *const *descriptors;
+ #if NPY_FEATURE_VERSION > NPY_2_3_API_VERSION
+    void * _reserved;
+    /* 
+     * Optional flag to pass information into the inner loop
+     * If set, it will be NPY_CASTING
+     */
+    uint64_t flags;
     /* Structure may grow (this is harmless for DType authors) */
+ #endif
 } PyArrayMethod_Context;
 
 
@@ -144,7 +152,6 @@ typedef struct {
 #define NPY_METH_contiguous_indexed_loop 9
 #define _NPY_METH_static_data 10
 
-
 /*
  * The resolve descriptors function, must be able to handle NULL values for
  * all output (but not input) `given_descrs` and fill `loop_descrs`.
diff --git a/numpy/_core/include/numpy/ndarraytypes.h b/numpy/_core/include/numpy/ndarraytypes.h
index baa42406ac88..972b25a7aa6e 100644
--- a/numpy/_core/include/numpy/ndarraytypes.h
+++ b/numpy/_core/include/numpy/ndarraytypes.h
@@ -227,6 +227,8 @@ typedef enum {
         NPY_SAME_KIND_CASTING=3,
         /* Allow any casts */
         NPY_UNSAFE_CASTING=4,
+        /* Allow any casts, check that no values overflow/change */
+        NPY_SAME_VALUE_CASTING=5,
 } NPY_CASTING;
 
 typedef enum {
diff --git a/numpy/_core/include/numpy/numpyconfig.h b/numpy/_core/include/numpy/numpyconfig.h
index 52d7e2b5d7d7..c129a3aceb6d 100644
--- a/numpy/_core/include/numpy/numpyconfig.h
+++ b/numpy/_core/include/numpy/numpyconfig.h
@@ -84,6 +84,7 @@
 #define NPY_2_1_API_VERSION 0x00000013
 #define NPY_2_2_API_VERSION 0x00000013
 #define NPY_2_3_API_VERSION 0x00000014
+#define NPY_2_4_API_VERSION 0x00000015
 
 
 /*
@@ -172,8 +173,10 @@
     #define NPY_FEATURE_VERSION_STRING "2.0"
 #elif NPY_FEATURE_VERSION == NPY_2_1_API_VERSION
     #define NPY_FEATURE_VERSION_STRING "2.1"
-#elif NPY_FEATURE_VERSION == NPY_2_3_API_VERSION  /* also 2.4 */
+#elif NPY_FEATURE_VERSION == NPY_2_3_API_VERSION
     #define NPY_FEATURE_VERSION_STRING "2.3"
+#elif NPY_FEATURE_VERSION == NPY_2_4_API_VERSION
+    #define NPY_FEATURE_VERSION_STRING "2.4"
 #else
     #error "Missing version string define for new NumPy version."
 #endif
diff --git a/numpy/_core/meson.build b/numpy/_core/meson.build
index a4d2050122c6..067d996d3a7f 100644
--- a/numpy/_core/meson.build
+++ b/numpy/_core/meson.build
@@ -50,7 +50,8 @@ C_ABI_VERSION = '0x02000000'
 # 0x00000013 - 2.1.x
 # 0x00000013 - 2.2.x
 # 0x00000014 - 2.3.x
-C_API_VERSION = '0x00000014'
+# 0x00000015 - 2.4.x
+C_API_VERSION = '0x00000015'
 
 # Check whether we have a mismatch between the set C API VERSION and the
 # actual C API VERSION. Will raise a MismatchCAPIError if so.
diff --git a/numpy/_core/src/common/array_assign.h b/numpy/_core/src/common/array_assign.h
index 8a28ed1d3a01..cc5f044ef080 100644
--- a/numpy/_core/src/common/array_assign.h
+++ b/numpy/_core/src/common/array_assign.h
@@ -46,7 +46,7 @@ PyArray_AssignRawScalar(PyArrayObject *dst,
 NPY_NO_EXPORT int
 raw_array_assign_scalar(int ndim, npy_intp const *shape,
         PyArray_Descr *dst_dtype, char *dst_data, npy_intp const *dst_strides,
-        PyArray_Descr *src_dtype, char *src_data);
+        PyArray_Descr *src_dtype, char *src_data, NPY_CASTING casting);
 
 /*
  * Assigns the scalar value to every element of the destination raw array
@@ -59,7 +59,7 @@ raw_array_wheremasked_assign_scalar(int ndim, npy_intp const *shape,
         PyArray_Descr *dst_dtype, char *dst_data, npy_intp const *dst_strides,
         PyArray_Descr *src_dtype, char *src_data,
         PyArray_Descr *wheremask_dtype, char *wheremask_data,
-        npy_intp const *wheremask_strides);
+        npy_intp const *wheremask_strides, NPY_CASTING casting);
 
 /******** LOW-LEVEL ARRAY MANIPULATION HELPERS ********/
 
diff --git a/numpy/_core/src/multiarray/_multiarray_tests.c.src b/numpy/_core/src/multiarray/_multiarray_tests.c.src
index 8012a32b070e..6d71dcdecedc 100644
--- a/numpy/_core/src/multiarray/_multiarray_tests.c.src
+++ b/numpy/_core/src/multiarray/_multiarray_tests.c.src
@@ -2168,6 +2168,7 @@ run_casting_converter(PyObject* NPY_UNUSED(self), PyObject *args)
         case NPY_SAFE_CASTING: return PyUnicode_FromString("NPY_SAFE_CASTING");
         case NPY_SAME_KIND_CASTING: return PyUnicode_FromString("NPY_SAME_KIND_CASTING");
         case NPY_UNSAFE_CASTING: return PyUnicode_FromString("NPY_UNSAFE_CASTING");
+        case NPY_SAME_VALUE_CASTING: return PyUnicode_FromString("NPY_SAME_VALUE_CASTING");
         default: return PyLong_FromLong(casting);
     }
 }
diff --git a/numpy/_core/src/multiarray/array_assign_array.c b/numpy/_core/src/multiarray/array_assign_array.c
index 8886d1cacb40..ec23eb6b8f10 100644
--- a/numpy/_core/src/multiarray/array_assign_array.c
+++ b/numpy/_core/src/multiarray/array_assign_array.c
@@ -79,7 +79,8 @@ copycast_isaligned(int ndim, npy_intp const *shape,
 NPY_NO_EXPORT int
 raw_array_assign_array(int ndim, npy_intp const *shape,
         PyArray_Descr *dst_dtype, char *dst_data, npy_intp const *dst_strides,
-        PyArray_Descr *src_dtype, char *src_data, npy_intp const *src_strides)
+        PyArray_Descr *src_dtype, char *src_data, npy_intp const *src_strides,
+        int flags)
 {
     int idim;
     npy_intp shape_it[NPY_MAXDIMS];
@@ -87,14 +88,11 @@ raw_array_assign_array(int ndim, npy_intp const *shape,
     npy_intp src_strides_it[NPY_MAXDIMS];
     npy_intp coord[NPY_MAXDIMS];
 
-    int aligned;
+    int aligned = flags & 0x01;
+    int same_value_cast = (flags & 0x02) == 0x02;
 
     NPY_BEGIN_THREADS_DEF;
 
-    aligned =
-        copycast_isaligned(ndim, shape, dst_dtype, dst_data, dst_strides) &&
-        copycast_isaligned(ndim, shape, src_dtype, src_data, src_strides);
-
     /* Use raw iteration with no heap allocation */
     if (PyArray_PrepareTwoRawArrayIter(
                     ndim, shape,
@@ -120,21 +118,30 @@ raw_array_assign_array(int ndim, npy_intp const *shape,
 
     /* Get the function to do the casting */
     NPY_cast_info cast_info;
-    NPY_ARRAYMETHOD_FLAGS flags;
+    NPY_ARRAYMETHOD_FLAGS method_flags;
     if (PyArray_GetDTypeTransferFunction(aligned,
                         src_strides_it[0], dst_strides_it[0],
                         src_dtype, dst_dtype,
                         0,
-                        &cast_info, &flags) != NPY_SUCCEED) {
+                        &cast_info, &method_flags) != NPY_SUCCEED) {
         return -1;
     }
 
-    if (!(flags & NPY_METH_NO_FLOATINGPOINT_ERRORS)) {
+    if (!(method_flags & NPY_METH_NO_FLOATINGPOINT_ERRORS)) {
         npy_clear_floatstatus_barrier((char*)&src_data);
     }
 
+    if (same_value_cast) {
+ #if NPY_FEATURE_VERSION > NPY_2_3_API_VERSION
+        cast_info.context.flags |= NPY_SAME_VALUE_CASTING;
+ #else
+        PyErr_SetString(PyExc_NotImplementedError, 
+            "raw_array_assign_array with 'same_value' casting not implemented yet");
+ #endif
+    }
+
     /* Ensure number of elements exceeds threshold for threading */
-    if (!(flags & NPY_METH_REQUIRES_PYAPI)) {
+    if (!(method_flags & NPY_METH_REQUIRES_PYAPI)) {
         npy_intp nitems = 1, i;
         for (i = 0; i < ndim; i++) {
             nitems *= shape_it[i];
@@ -144,11 +151,14 @@ raw_array_assign_array(int ndim, npy_intp const *shape,
 
     npy_intp strides[2] = {src_strides_it[0], dst_strides_it[0]};
 
+    int result = 0;
     NPY_RAW_ITER_START(idim, ndim, coord, shape_it) {
         /* Process the innermost dimension */
         char *args[2] = {src_data, dst_data};
-        if (cast_info.func(&cast_info.context,
-                args, &shape_it[0], strides, cast_info.auxdata) < 0) {
+        result = cast_info.func(&cast_info.context,
+                                args, &shape_it[0], strides,
+                                cast_info.auxdata);
+        if (result < 0) {
             goto fail;
         }
     } NPY_RAW_ITER_TWO_NEXT(idim, ndim, coord, shape_it,
@@ -158,7 +168,7 @@ raw_array_assign_array(int ndim, npy_intp const *shape,
     NPY_END_THREADS;
     NPY_cast_info_xfree(&cast_info);
 
-    if (!(flags & NPY_METH_NO_FLOATINGPOINT_ERRORS)) {
+    if (!(method_flags & NPY_METH_NO_FLOATINGPOINT_ERRORS)) {
         int fpes = npy_get_floatstatus_barrier((char*)&src_data);
         if (fpes && PyUFunc_GiveFloatingpointErrors("cast", fpes) < 0) {
             return -1;
@@ -169,6 +179,7 @@ raw_array_assign_array(int ndim, npy_intp const *shape,
 fail:
     NPY_END_THREADS;
     NPY_cast_info_xfree(&cast_info);
+    HandleArrayMethodError(result, "astype", method_flags); 
     return -1;
 }
 
@@ -183,7 +194,7 @@ raw_array_wheremasked_assign_array(int ndim, npy_intp const *shape,
         PyArray_Descr *dst_dtype, char *dst_data, npy_intp const *dst_strides,
         PyArray_Descr *src_dtype, char *src_data, npy_intp const *src_strides,
         PyArray_Descr *wheremask_dtype, char *wheremask_data,
-        npy_intp const *wheremask_strides)
+        npy_intp const *wheremask_strides, int flags)
 {
     int idim;
     npy_intp shape_it[NPY_MAXDIMS];
@@ -192,14 +203,11 @@ raw_array_wheremasked_assign_array(int ndim, npy_intp const *shape,
     npy_intp wheremask_strides_it[NPY_MAXDIMS];
     npy_intp coord[NPY_MAXDIMS];
 
-    int aligned;
+    int aligned = flags & 0x01;
+    int same_value_cast = (flags & 0x02) == 0x02;
 
     NPY_BEGIN_THREADS_DEF;
 
-    aligned =
-        copycast_isaligned(ndim, shape, dst_dtype, dst_data, dst_strides) &&
-        copycast_isaligned(ndim, shape, src_dtype, src_data, src_strides);
-
     /* Use raw iteration with no heap allocation */
     if (PyArray_PrepareThreeRawArrayIter(
                     ndim, shape,
@@ -229,39 +237,48 @@ raw_array_wheremasked_assign_array(int ndim, npy_intp const *shape,
 
     /* Get the function to do the casting */
     NPY_cast_info cast_info;
-    NPY_ARRAYMETHOD_FLAGS flags;
+    NPY_ARRAYMETHOD_FLAGS method_flags;
     if (PyArray_GetMaskedDTypeTransferFunction(aligned,
                         src_strides_it[0],
                         dst_strides_it[0],
                         wheremask_strides_it[0],
                         src_dtype, dst_dtype, wheremask_dtype,
                         0,
-                        &cast_info, &flags) != NPY_SUCCEED) {
+                        &cast_info, &method_flags) != NPY_SUCCEED) {
+        return -1;
+    }
+    if (same_value_cast) {
+        /* cast_info.context.flags |= NPY_SAME_VALUE_CASTING; */
+        PyErr_SetString(PyExc_NotImplementedError,
+            "raw_array_wheremasked_assign_array with 'same_value' casting not implemented yet");
         return -1;
     }
 
-    if (!(flags & NPY_METH_NO_FLOATINGPOINT_ERRORS)) {
+    if (!(method_flags & NPY_METH_NO_FLOATINGPOINT_ERRORS)) {
         npy_clear_floatstatus_barrier(src_data);
     }
-    if (!(flags & NPY_METH_REQUIRES_PYAPI)) {
+    if (!(method_flags & NPY_METH_REQUIRES_PYAPI)) {
         npy_intp nitems = 1, i;
         for (i = 0; i < ndim; i++) {
             nitems *= shape_it[i];
         }
         NPY_BEGIN_THREADS_THRESHOLDED(nitems);
     }
+
     npy_intp strides[2] = {src_strides_it[0], dst_strides_it[0]};
 
+    int result = 0;
     NPY_RAW_ITER_START(idim, ndim, coord, shape_it) {
         PyArray_MaskedStridedUnaryOp *stransfer;
         stransfer = (PyArray_MaskedStridedUnaryOp *)cast_info.func;
 
         /* Process the innermost dimension */
         char *args[2] = {src_data, dst_data};
-        if (stransfer(&cast_info.context,
-                args, &shape_it[0], strides,
-                (npy_bool *)wheremask_data, wheremask_strides_it[0],
-                cast_info.auxdata) < 0) {
+        result = stransfer(&cast_info.context,
+                            args, &shape_it[0], strides,
+                            (npy_bool *)wheremask_data, wheremask_strides_it[0],
+                            cast_info.auxdata);
+        if (result < 0) {
             goto fail;
         }
     } NPY_RAW_ITER_THREE_NEXT(idim, ndim, coord, shape_it,
@@ -272,18 +289,17 @@ raw_array_wheremasked_assign_array(int ndim, npy_intp const *shape,
     NPY_END_THREADS;
     NPY_cast_info_xfree(&cast_info);
 
-    if (!(flags & NPY_METH_NO_FLOATINGPOINT_ERRORS)) {
+    if (!(method_flags & NPY_METH_NO_FLOATINGPOINT_ERRORS)) {
         int fpes = npy_get_floatstatus_barrier(src_data);
         if (fpes && PyUFunc_GiveFloatingpointErrors("cast", fpes) < 0) {
             return -1;
         }
     }
-
     return 0;
-
 fail:
     NPY_END_THREADS;
     NPY_cast_info_xfree(&cast_info);
+    HandleArrayMethodError(result, "astype", method_flags); 
     return -1;
 }
 
@@ -307,7 +323,6 @@ PyArray_AssignArray(PyArrayObject *dst, PyArrayObject *src,
                     NPY_CASTING casting)
 {
     int copied_src = 0;
-
     npy_intp src_strides[NPY_MAXDIMS];
 
     /* Use array_assign_scalar if 'src' NDIM is 0 */
@@ -438,12 +453,17 @@ PyArray_AssignArray(PyArrayObject *dst, PyArrayObject *src,
         }
     }
 
+    int aligned =
+        copycast_isaligned(PyArray_NDIM(dst), PyArray_DIMS(dst), PyArray_DESCR(dst), PyArray_DATA(dst), PyArray_STRIDES(dst)) &&
+        copycast_isaligned(PyArray_NDIM(dst), PyArray_DIMS(dst), PyArray_DESCR(src), PyArray_DATA(src), src_strides);
+    int flags = ((NPY_SAME_VALUE_CASTING == casting) << 1) | aligned;
+
     if (wheremask == NULL) {
         /* A straightforward value assignment */
         /* Do the assignment with raw array iteration */
         if (raw_array_assign_array(PyArray_NDIM(dst), PyArray_DIMS(dst),
                 PyArray_DESCR(dst), PyArray_DATA(dst), PyArray_STRIDES(dst),
-                PyArray_DESCR(src), PyArray_DATA(src), src_strides) < 0) {
+                PyArray_DESCR(src), PyArray_DATA(src), src_strides, flags) < 0){
             goto fail;
         }
     }
@@ -465,7 +485,7 @@ PyArray_AssignArray(PyArrayObject *dst, PyArrayObject *src,
                 PyArray_DESCR(dst), PyArray_DATA(dst), PyArray_STRIDES(dst),
                 PyArray_DESCR(src), PyArray_DATA(src), src_strides,
                 PyArray_DESCR(wheremask), PyArray_DATA(wheremask),
-                        wheremask_strides) < 0) {
+                        wheremask_strides, flags) < 0) {
             goto fail;
         }
     }
diff --git a/numpy/_core/src/multiarray/array_assign_scalar.c b/numpy/_core/src/multiarray/array_assign_scalar.c
index 0199ba969eb9..e4a62d3ac9e6 100644
--- a/numpy/_core/src/multiarray/array_assign_scalar.c
+++ b/numpy/_core/src/multiarray/array_assign_scalar.c
@@ -37,7 +37,7 @@
 NPY_NO_EXPORT int
 raw_array_assign_scalar(int ndim, npy_intp const *shape,
         PyArray_Descr *dst_dtype, char *dst_data, npy_intp const *dst_strides,
-        PyArray_Descr *src_dtype, char *src_data)
+        PyArray_Descr *src_dtype, char *src_data, NPY_CASTING casting)
 {
     int idim;
     npy_intp shape_it[NPY_MAXDIMS], dst_strides_it[NPY_MAXDIMS];
@@ -86,13 +86,21 @@ raw_array_assign_scalar(int ndim, npy_intp const *shape,
         NPY_BEGIN_THREADS_THRESHOLDED(nitems);
     }
 
+    if (casting == NPY_SAME_VALUE_CASTING) {
+        /* cast_info.context.flags |= NPY_SAME_VALUE_CASTING; */
+        PyErr_SetString(PyExc_NotImplementedError, "'same_value' casting not implemented yet");
+        return -1;
+    }
+
     npy_intp strides[2] = {0, dst_strides_it[0]};
 
+    int result = 0;
     NPY_RAW_ITER_START(idim, ndim, coord, shape_it) {
         /* Process the innermost dimension */
         char *args[2] = {src_data, dst_data};
-        if (cast_info.func(&cast_info.context,
-                args, &shape_it[0], strides, cast_info.auxdata) < 0) {
+        result = cast_info.func(&cast_info.context,
+                args, &shape_it[0], strides, cast_info.auxdata);
+        if (result < 0) {
             goto fail;
         }
     } NPY_RAW_ITER_ONE_NEXT(idim, ndim, coord,
@@ -112,6 +120,7 @@ raw_array_assign_scalar(int ndim, npy_intp const *shape,
 fail:
     NPY_END_THREADS;
     NPY_cast_info_xfree(&cast_info);
+    HandleArrayMethodError(result, "cast", flags); 
     return -1;
 }
 
@@ -126,7 +135,7 @@ raw_array_wheremasked_assign_scalar(int ndim, npy_intp const *shape,
         PyArray_Descr *dst_dtype, char *dst_data, npy_intp const *dst_strides,
         PyArray_Descr *src_dtype, char *src_data,
         PyArray_Descr *wheremask_dtype, char *wheremask_data,
-        npy_intp const *wheremask_strides)
+        npy_intp const *wheremask_strides, NPY_CASTING casting)
 {
     int idim;
     npy_intp shape_it[NPY_MAXDIMS], dst_strides_it[NPY_MAXDIMS];
@@ -177,8 +186,14 @@ raw_array_wheremasked_assign_scalar(int ndim, npy_intp const *shape,
         }
         NPY_BEGIN_THREADS_THRESHOLDED(nitems);
     }
+    if (casting == NPY_SAME_VALUE_CASTING) {
+        /* cast_info.context.flags |= NPY_SAME_VALUE_CASTING; */
+        PyErr_SetString(PyExc_NotImplementedError, "'same_value' casting not implemented yet");
+        return -1;
+    }
 
     npy_intp strides[2] = {0, dst_strides_it[0]};
+    int result = 0;
 
     NPY_RAW_ITER_START(idim, ndim, coord, shape_it) {
         /* Process the innermost dimension */
@@ -186,10 +201,11 @@ raw_array_wheremasked_assign_scalar(int ndim, npy_intp const *shape,
         stransfer = (PyArray_MaskedStridedUnaryOp *)cast_info.func;
 
         char *args[2] = {src_data, dst_data};
-        if (stransfer(&cast_info.context,
+        result = stransfer(&cast_info.context,
                 args, &shape_it[0], strides,
                 (npy_bool *)wheremask_data, wheremask_strides_it[0],
-                cast_info.auxdata) < 0) {
+                cast_info.auxdata);
+        if (result < 0) {
             goto fail;
         }
     } NPY_RAW_ITER_TWO_NEXT(idim, ndim, coord, shape_it,
@@ -211,6 +227,7 @@ raw_array_wheremasked_assign_scalar(int ndim, npy_intp const *shape,
 fail:
     NPY_END_THREADS;
     NPY_cast_info_xfree(&cast_info);
+    HandleArrayMethodError(result, "cast", flags); 
     return -1;
 }
 
@@ -298,7 +315,7 @@ PyArray_AssignRawScalar(PyArrayObject *dst,
         /* Do the assignment with raw array iteration */
         if (raw_array_assign_scalar(PyArray_NDIM(dst), PyArray_DIMS(dst),
                 PyArray_DESCR(dst), PyArray_DATA(dst), PyArray_STRIDES(dst),
-                src_dtype, src_data) < 0) {
+                src_dtype, src_data, casting) < 0) {
             goto fail;
         }
     }
@@ -319,7 +336,7 @@ PyArray_AssignRawScalar(PyArrayObject *dst,
                 PyArray_DESCR(dst), PyArray_DATA(dst), PyArray_STRIDES(dst),
                 src_dtype, src_data,
                 PyArray_DESCR(wheremask), PyArray_DATA(wheremask),
-                wheremask_strides) < 0) {
+                wheremask_strides, casting) < 0) {
             goto fail;
         }
     }
diff --git a/numpy/_core/src/multiarray/array_coercion.c b/numpy/_core/src/multiarray/array_coercion.c
index ff7d98bd9c64..1bd787167a15 100644
--- a/numpy/_core/src/multiarray/array_coercion.c
+++ b/numpy/_core/src/multiarray/array_coercion.c
@@ -418,9 +418,12 @@ npy_cast_raw_scalar_item(
     char *args[2] = {from_item, to_item};
     const npy_intp strides[2] = {0, 0};
     const npy_intp length = 1;
-    if (cast_info.func(&cast_info.context,
-            args, &length, strides, cast_info.auxdata) < 0) {
+    int result = 0;
+    result = cast_info.func(&cast_info.context,
+            args, &length, strides, cast_info.auxdata);
+    if (result < 0) {
         NPY_cast_info_xfree(&cast_info);
+        HandleArrayMethodError(result, "cast", flags); 
         return -1;
     }
     NPY_cast_info_xfree(&cast_info);
diff --git a/numpy/_core/src/multiarray/array_method.c b/numpy/_core/src/multiarray/array_method.c
index 5554cad5e2dd..bf913cf5fd1b 100644
--- a/numpy/_core/src/multiarray/array_method.c
+++ b/numpy/_core/src/multiarray/array_method.c
@@ -39,6 +39,7 @@
 #include "convert_datatype.h"
 #include "common.h"
 #include "numpy/ufuncobject.h"
+#include "dtype_transfer.h"
 
 
 /*
@@ -190,6 +191,7 @@ validate_spec(PyArrayMethod_Spec *spec)
         case NPY_SAFE_CASTING:
         case NPY_SAME_KIND_CASTING:
         case NPY_UNSAFE_CASTING:
+        case NPY_SAME_VALUE_CASTING:
             break;
         default:
             if (spec->casting != -1) {
@@ -792,11 +794,10 @@ boundarraymethod__simple_strided_call(
         return NULL;
     }
 
-    PyArrayMethod_Context context = {
-            .caller = NULL,
-            .method = self->method,
-            .descriptors = descrs,
-    };
+    PyArrayMethod_Context context;
+    NPY_context_init(&context, descrs);
+    context.method = self->method;
+
     PyArrayMethod_StridedLoop *strided_loop = NULL;
     NpyAuxData *loop_data = NULL;
     NPY_ARRAYMETHOD_FLAGS flags = 0;
@@ -984,3 +985,12 @@ NPY_NO_EXPORT PyTypeObject PyBoundArrayMethod_Type = {
     .tp_methods = boundarraymethod_methods,
     .tp_getset = boundarraymethods_getters,
 };
+
+int HandleArrayMethodError(int result, const char * name , int method_flags)
+{
+    if (result == NPY_SAME_VALUE_FAILURE) {
+        PyErr_Format(PyExc_ValueError, "'same_value' casting failure in %s", name);
+    }
+    return result;
+}
+
diff --git a/numpy/_core/src/multiarray/array_method.h b/numpy/_core/src/multiarray/array_method.h
index bcf270899f13..3e87868f02d9 100644
--- a/numpy/_core/src/multiarray/array_method.h
+++ b/numpy/_core/src/multiarray/array_method.h
@@ -122,6 +122,15 @@ PyArrayMethod_FromSpec(PyArrayMethod_Spec *spec);
 NPY_NO_EXPORT PyBoundArrayMethodObject *
 PyArrayMethod_FromSpec_int(PyArrayMethod_Spec *spec, int priv);
 
+/*
+ * Possible results to be handled in HandleArrayMethodError, after a call
+ * to a PyArrayMethod_StridedLoop
+ */
+#define NPY_GENERIC_LOOP_FAILURE -1   /* will have set a PyErr already */
+#define NPY_SAME_VALUE_FAILURE -31    /* same_value casting failed */
+ 
+int HandleArrayMethodError(int result, const char * name , int method_flags);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/numpy/_core/src/multiarray/common.c b/numpy/_core/src/multiarray/common.c
index 8236ec5c65ae..4d1d9c238418 100644
--- a/numpy/_core/src/multiarray/common.c
+++ b/numpy/_core/src/multiarray/common.c
@@ -25,15 +25,6 @@
  * variable is misnamed, but it's part of the public API so I'm not sure we
  * can just change it. Maybe someone should try and see if anyone notices.
  */
-/*
- * In numpy 1.6 and earlier, this was NPY_UNSAFE_CASTING. In a future
- * release, it will become NPY_SAME_KIND_CASTING.  Right now, during the
- * transitional period, we continue to follow the NPY_UNSAFE_CASTING rules (to
- * avoid breaking people's code), but we also check for whether the cast would
- * be allowed under the NPY_SAME_KIND_CASTING rules, and if not we issue a
- * warning (that people's code will be broken in a future release.)
- */
-
 NPY_NO_EXPORT NPY_CASTING NPY_DEFAULT_ASSIGN_CASTING = NPY_SAME_KIND_CASTING;
 
 
diff --git a/numpy/_core/src/multiarray/conversion_utils.c b/numpy/_core/src/multiarray/conversion_utils.c
index 5ada3e6e4faf..d6b0706c1d9b 100644
--- a/numpy/_core/src/multiarray/conversion_utils.c
+++ b/numpy/_core/src/multiarray/conversion_utils.c
@@ -949,6 +949,10 @@ static int casting_parser(char const *str, Py_ssize_t length, void *data)
             *casting = NPY_SAME_KIND_CASTING;
             return 0;
         }
+        if (length == 10 && strcmp(str, "same_value") == 0) {
+            *casting = NPY_SAME_VALUE_CASTING;
+            return 0;
+        }
         break;
     case 's':
         if (length == 6 && strcmp(str, "unsafe") == 0) {
@@ -969,7 +973,7 @@ PyArray_CastingConverter(PyObject *obj, NPY_CASTING *casting)
     return string_converter_helper(
         obj, (void *)casting, casting_parser, "casting",
             "must be one of 'no', 'equiv', 'safe', "
-            "'same_kind', or 'unsafe'");
+            "'same_kind', 'unsafe', or 'same_value'");
     return 0;
 }
 
diff --git a/numpy/_core/src/multiarray/convert.c b/numpy/_core/src/multiarray/convert.c
index 8e0177616955..983d9bc19ce6 100644
--- a/numpy/_core/src/multiarray/convert.c
+++ b/numpy/_core/src/multiarray/convert.c
@@ -429,7 +429,7 @@ PyArray_FillWithScalar(PyArrayObject *arr, PyObject *obj)
     int retcode = raw_array_assign_scalar(
             PyArray_NDIM(arr), PyArray_DIMS(arr), descr,
             PyArray_BYTES(arr), PyArray_STRIDES(arr),
-            descr, (void *)value);
+            descr, (void *)value, NPY_UNSAFE_CASTING);
 
     if (PyDataType_REFCHK(descr)) {
         PyArray_ClearBuffer(descr, (void *)value, 0, 1, 1);
diff --git a/numpy/_core/src/multiarray/convert_datatype.c b/numpy/_core/src/multiarray/convert_datatype.c
index 59b6298b5815..65704e06a013 100644
--- a/numpy/_core/src/multiarray/convert_datatype.c
+++ b/numpy/_core/src/multiarray/convert_datatype.c
@@ -746,13 +746,13 @@ can_cast_pyscalar_scalar_to(
     }
     else if (PyDataType_ISFLOAT(to)) {
         if (flags & NPY_ARRAY_WAS_PYTHON_COMPLEX) {
-            return casting == NPY_UNSAFE_CASTING;
+            return ((casting == NPY_UNSAFE_CASTING) || (casting == NPY_SAME_VALUE_CASTING));
         }
         return 1;
     }
     else if (PyDataType_ISINTEGER(to)) {
         if (!(flags & NPY_ARRAY_WAS_PYTHON_INT)) {
-            return casting == NPY_UNSAFE_CASTING;
+            return ((casting == NPY_UNSAFE_CASTING) || (casting == NPY_SAME_VALUE_CASTING));
         }
         return 1;
     }
@@ -839,6 +839,8 @@ npy_casting_to_string(NPY_CASTING casting)
             return "'same_kind'";
         case NPY_UNSAFE_CASTING:
             return "'unsafe'";
+        case NPY_SAME_VALUE_CASTING:
+            return "'same_value'";
         default:
             return "<unknown>";
     }
@@ -2463,10 +2465,10 @@ cast_to_string_resolve_descriptors(
         return -1;
     }
 
-    if (self->casting == NPY_UNSAFE_CASTING) {
+    if ((self->casting == NPY_UNSAFE_CASTING) || (self->casting == NPY_SAME_VALUE_CASTING)){
         assert(dtypes[0]->type_num == NPY_UNICODE &&
                dtypes[1]->type_num == NPY_STRING);
-        return NPY_UNSAFE_CASTING;
+        return self->casting;
     }
 
     if (loop_descrs[1]->elsize >= size) {
diff --git a/numpy/_core/src/multiarray/ctors.c b/numpy/_core/src/multiarray/ctors.c
index f7efe5041ab3..35b4f3837261 100644
--- a/numpy/_core/src/multiarray/ctors.c
+++ b/numpy/_core/src/multiarray/ctors.c
@@ -2789,12 +2789,13 @@ PyArray_CopyAsFlat(PyArrayObject *dst, PyArrayObject *src, NPY_ORDER order)
     npy_intp strides[2] = {src_stride, dst_stride};
 
     int res = 0;
+    int result = 0;
     for(;;) {
         /* Transfer the biggest amount that fits both */
         count = (src_count < dst_count) ? src_count : dst_count;
-        if (cast_info.func(&cast_info.context,
-                args, &count, strides, cast_info.auxdata) < 0) {
-            res = -1;
+        result = cast_info.func(&cast_info.context,
+                args, &count, strides, cast_info.auxdata);
+        if (result < 0) {
             break;
         }
 
@@ -2836,6 +2837,10 @@ PyArray_CopyAsFlat(PyArrayObject *dst, PyArrayObject *src, NPY_ORDER order)
     if (!NpyIter_Deallocate(src_iter)) {
         res = -1;
     }
+    if (result < 0) {
+        HandleArrayMethodError(result, "cast", flags);
+        res = result;
+    }
 
     if (res == 0 && !(flags & NPY_METH_NO_FLOATINGPOINT_ERRORS)) {
         int fpes = npy_get_floatstatus_barrier((char *)&src_iter);
diff --git a/numpy/_core/src/multiarray/datetime.c b/numpy/_core/src/multiarray/datetime.c
index 9c024dbcd91c..228a53fdfba4 100644
--- a/numpy/_core/src/multiarray/datetime.c
+++ b/numpy/_core/src/multiarray/datetime.c
@@ -1261,6 +1261,8 @@ can_cast_datetime64_units(NPY_DATETIMEUNIT src_unit,
                 return (src_unit <= dst_unit);
             }
 
+        case NPY_SAME_VALUE_CASTING:
+            return 0;
         /* Enforce equality with 'no' or 'equiv' casting */
         default:
             return src_unit == dst_unit;
@@ -1302,6 +1304,7 @@ can_cast_timedelta64_units(NPY_DATETIMEUNIT src_unit,
          * 'safe' casting.
          */
         case NPY_SAFE_CASTING:
+        case NPY_SAME_VALUE_CASTING:
             if (src_unit == NPY_FR_GENERIC || dst_unit == NPY_FR_GENERIC) {
                 return src_unit == NPY_FR_GENERIC;
             }
@@ -1334,6 +1337,7 @@ can_cast_datetime64_metadata(PyArray_DatetimeMetaData *src_meta,
                                              casting);
 
         case NPY_SAFE_CASTING:
+        case NPY_SAME_VALUE_CASTING:
             return can_cast_datetime64_units(src_meta->base, dst_meta->base,
                                                              casting) &&
                    datetime_metadata_divides(src_meta, dst_meta, 0);
@@ -1361,6 +1365,7 @@ can_cast_timedelta64_metadata(PyArray_DatetimeMetaData *src_meta,
                                              casting);
 
         case NPY_SAFE_CASTING:
+        case NPY_SAME_VALUE_CASTING:
             return can_cast_timedelta64_units(src_meta->base, dst_meta->base,
                                                              casting) &&
                    datetime_metadata_divides(src_meta, dst_meta, 1);
diff --git a/numpy/_core/src/multiarray/datetime_strings.c b/numpy/_core/src/multiarray/datetime_strings.c
index f92eec3f5a59..d3011d082325 100644
--- a/numpy/_core/src/multiarray/datetime_strings.c
+++ b/numpy/_core/src/multiarray/datetime_strings.c
@@ -984,7 +984,7 @@ NpyDatetime_MakeISO8601Datetime(
      * the string representation, so ensure that the data
      * is being cast according to the casting rule.
      */
-    if (casting != NPY_UNSAFE_CASTING) {
+    if ((casting != NPY_UNSAFE_CASTING) && (casting != NPY_SAME_VALUE_CASTING)) {
         /* Producing a date as a local time is always 'unsafe' */
         if (base <= NPY_FR_D && local) {
             PyErr_SetString(PyExc_TypeError, "Cannot create a local "
diff --git a/numpy/_core/src/multiarray/dtype_transfer.c b/numpy/_core/src/multiarray/dtype_transfer.c
index 188a55a4b5f5..a93420587b34 100644
--- a/numpy/_core/src/multiarray/dtype_transfer.c
+++ b/numpy/_core/src/multiarray/dtype_transfer.c
@@ -2910,8 +2910,6 @@ _clear_cast_info_after_get_loop_failure(NPY_cast_info *cast_info)
  * TODO: Expand the view functionality for general offsets, not just 0:
  *       Partial casts could be skipped also for `view_offset != 0`.
  *
- * The `out_needs_api` flag must be initialized.
- *
  * NOTE: In theory casting errors here could be slightly misleading in case
  *       of a multi-step casting scenario. It should be possible to improve
  *       this in the future.
@@ -3428,11 +3426,14 @@ PyArray_CastRawArrays(npy_intp count,
     /* Cast */
     char *args[2] = {src, dst};
     npy_intp strides[2] = {src_stride, dst_stride};
-    cast_info.func(&cast_info.context, args, &count, strides, cast_info.auxdata);
+    int result = cast_info.func(&cast_info.context, args, &count, strides, cast_info.auxdata);
 
     /* Cleanup */
     NPY_cast_info_xfree(&cast_info);
-
+    if (result < 0) {
+        HandleArrayMethodError(result, "cast", flags);
+        return NPY_FAIL;
+    }
     if (flags & NPY_METH_REQUIRES_PYAPI && PyErr_Occurred()) {
         return NPY_FAIL;
     }
diff --git a/numpy/_core/src/multiarray/dtype_transfer.h b/numpy/_core/src/multiarray/dtype_transfer.h
index 04df5cb64c22..304f6dc3a8c5 100644
--- a/numpy/_core/src/multiarray/dtype_transfer.h
+++ b/numpy/_core/src/multiarray/dtype_transfer.h
@@ -25,6 +25,17 @@ typedef struct {
 } NPY_cast_info;
 
 
+static inline void
+NPY_context_init(PyArrayMethod_Context *context, PyArray_Descr *descr[2])
+{
+    context->descriptors = descr;
+    context->caller = NULL;
+ #if NPY_FEATURE_VERSION > NPY_2_3_API_VERSION
+    context->_reserved = NULL;
+    context->flags = 0;
+ #endif
+}
+
 /*
  * Create a new cast-info struct with cast_info->context.descriptors linked.
  * Compilers should inline this to ensure the whole struct is not actually
@@ -40,13 +51,9 @@ NPY_cast_info_init(NPY_cast_info *cast_info)
      * a scratch space to `NPY_cast_info` and link to that instead.
      */
     cast_info->auxdata = NULL;
-    cast_info->context.descriptors = cast_info->descriptors;
-
-    // TODO: Delete this again probably maybe create a new minimal init macro
-    cast_info->context.caller = NULL;
+    NPY_context_init(&(cast_info->context), cast_info->descriptors);
 }
 
-
 /*
  * Free's all references and data held inside the struct (not the struct).
  * First checks whether `cast_info.func == NULL`, and assume it is
@@ -90,18 +97,19 @@ NPY_cast_info_move(NPY_cast_info *cast_info, NPY_cast_info *original)
 static inline int
 NPY_cast_info_copy(NPY_cast_info *cast_info, NPY_cast_info *original)
 {
+    /* First copy the context, but override the descriptors */
+    cast_info->context = original->context;
+    Py_XINCREF(cast_info->context.caller);
+    Py_XINCREF(cast_info->context.method);
     cast_info->context.descriptors = cast_info->descriptors;
 
+    /* Now copy the rest of the fields */
     assert(original->func != NULL);
     cast_info->func = original->func;
     cast_info->descriptors[0] = original->descriptors[0];
     Py_XINCREF(cast_info->descriptors[0]);
     cast_info->descriptors[1] = original->descriptors[1];
     Py_XINCREF(cast_info->descriptors[1]);
-    cast_info->context.caller = original->context.caller;
-    Py_XINCREF(cast_info->context.caller);
-    cast_info->context.method = original->context.method;
-    Py_XINCREF(cast_info->context.method);
     if (original->auxdata == NULL) {
         cast_info->auxdata = NULL;
         return 0;
diff --git a/numpy/_core/src/multiarray/einsum.c.src b/numpy/_core/src/multiarray/einsum.c.src
index 3733c436cb1b..6879fe1e02bd 100644
--- a/numpy/_core/src/multiarray/einsum.c.src
+++ b/numpy/_core/src/multiarray/einsum.c.src
@@ -830,6 +830,12 @@ PyArray_EinsteinSum(char *subscripts, npy_intp nop,
         return NULL;
     }
 
+    if (casting == NPY_SAME_VALUE_CASTING) {
+        PyErr_SetString(PyExc_NotImplementedError,
+            "einsum with casting='same_value' not implemented yet");
+        return NULL;
+    }
+
     /* Parse the subscripts string into label_counts and op_labels */
     memset(label_counts, 0, sizeof(label_counts));
     for (iop = 0; iop < nop; ++iop) {
diff --git a/numpy/_core/src/multiarray/legacy_dtype_implementation.c b/numpy/_core/src/multiarray/legacy_dtype_implementation.c
index 70b4fa1e49db..5c729a1baf30 100644
--- a/numpy/_core/src/multiarray/legacy_dtype_implementation.c
+++ b/numpy/_core/src/multiarray/legacy_dtype_implementation.c
@@ -367,7 +367,7 @@ PyArray_LegacyCanCastTypeTo(PyArray_Descr *from, PyArray_Descr *to,
          * field; recurse just in case the single field is itself structured.
          */
         if (!PyDataType_HASFIELDS(to) && !PyDataType_ISOBJECT(to)) {
-            if (casting == NPY_UNSAFE_CASTING &&
+            if ((casting == NPY_UNSAFE_CASTING || (casting == NPY_SAME_VALUE_CASTING)) &&
                     PyDict_Size(lfrom->fields) == 1) {
                 Py_ssize_t ppos = 0;
                 PyObject *tuple;
@@ -399,7 +399,7 @@ PyArray_LegacyCanCastTypeTo(PyArray_Descr *from, PyArray_Descr *to,
          * casting; this is not correct, but needed since the treatment in can_cast
          * below got out of sync with astype; see gh-13667.
          */
-        if (casting == NPY_UNSAFE_CASTING) {
+        if (casting == NPY_UNSAFE_CASTING || casting == NPY_SAME_VALUE_CASTING) {
             return 1;
         }
     }
@@ -408,14 +408,14 @@ PyArray_LegacyCanCastTypeTo(PyArray_Descr *from, PyArray_Descr *to,
          * If "from" is a simple data type and "to" has fields, then only
          * unsafe casting works (and that works always, even to multiple fields).
          */
-        return casting == NPY_UNSAFE_CASTING;
+        return (casting == NPY_UNSAFE_CASTING || casting == NPY_SAME_VALUE_CASTING);
     }
     /*
      * Everything else we consider castable for unsafe for now.
      * FIXME: ensure what we do here is consistent with "astype",
      * i.e., deal more correctly with subarrays and user-defined dtype.
      */
-    else if (casting == NPY_UNSAFE_CASTING) {
+    else if (casting == NPY_UNSAFE_CASTING || casting == NPY_SAME_VALUE_CASTING) {
         return 1;
     }
     /*
diff --git a/numpy/_core/src/multiarray/lowlevel_strided_loops.c.src b/numpy/_core/src/multiarray/lowlevel_strided_loops.c.src
index 01ffd225274f..3a110ea40646 100644
--- a/numpy/_core/src/multiarray/lowlevel_strided_loops.c.src
+++ b/numpy/_core/src/multiarray/lowlevel_strided_loops.c.src
@@ -17,6 +17,7 @@
 #include <numpy/arrayobject.h>
 #include <numpy/npy_cpu.h>
 #include <numpy/halffloat.h>
+#include <float.h>
 
 #include "lowlevel_strided_loops.h"
 #include "array_assign.h"
@@ -746,6 +747,7 @@ NPY_NO_EXPORT PyArrayMethod_StridedLoop *
  * #is_float1 = 0*12, 1, 0, 0, 1, 0, 0#
  * #is_double1 = 0*13, 1, 0, 0, 1, 0#
  * #is_complex1 = 0*15, 1*3#
+ * #is_unsigned1 = 1*6, 0*12#
  */
 
 /**begin repeat1
@@ -770,6 +772,16 @@ NPY_NO_EXPORT PyArrayMethod_StridedLoop *
  *          npy_byte, npy_short, npy_int, npy_long, npy_longlong,
  *          _npy_half, npy_float, npy_double, npy_longdouble,
  *          npy_float, npy_double, npy_longdouble#
+ * #type2max = 0,
+ *          UCHAR_MAX, USHRT_MAX, UINT_MAX, ULONG_MAX, ULLONG_MAX,
+ *          SCHAR_MAX,  SHRT_MAX,  INT_MAX,  LONG_MAX,  LLONG_MAX,
+ *          65500, FLT_MAX, DBL_MAX, LDBL_MAX,
+ *          FLT_MAX, DBL_MAX, LDBL_MAX#
+ * #type2min = 0,
+ *          0, 0, 0, 0, 0,
+ *           CHAR_MIN,  SHRT_MIN,  INT_MIN,  LONG_MIN,  LLONG_MIN,
+ *          -65500, -FLT_MAX, -DBL_MAX, -LDBL_MAX,
+ *          -FLT_MAX, -DBL_MAX, -LDBL_MAX#
  * #is_bool2 = 1, 0*17#
  * #is_emu_half2 = 0*11, EMULATED_FP16, 0*6#
  * #is_native_half2 = 0*11, NATIVE_FP16, 0*6#
@@ -814,7 +826,7 @@ NPY_NO_EXPORT PyArrayMethod_StridedLoop *
 
 /* Determine an appropriate casting conversion function */
 #if @is_emu_half1@
-
+#  define _TO_RTYPE1(x) npy_half_to_float(x)
 #  if @is_float2@
 #    define _CONVERT_FN(x) npy_halfbits_to_floatbits(x)
 #  elif @is_double2@
@@ -828,6 +840,7 @@ NPY_NO_EXPORT PyArrayMethod_StridedLoop *
 #  endif
 
 #elif @is_emu_half2@
+#  define _TO_RTYPE1(x) (@rtype1@)(x)
 
 #  if @is_float1@
 #    define _CONVERT_FN(x) npy_floatbits_to_halfbits(x)
@@ -842,6 +855,7 @@ NPY_NO_EXPORT PyArrayMethod_StridedLoop *
 #  endif
 
 #else
+#  define _TO_RTYPE1(x) (@rtype1@)(x)
 
 #  if @is_bool2@ || @is_bool1@
 #    define _CONVERT_FN(x) ((npy_bool)(x != 0))
@@ -903,6 +917,13 @@ static GCC_CAST_OPT_LEVEL int
 #endif
 
     /*printf("@prefix@_cast_@name1@_to_@name2@\n");*/
+#if !@is_bool2@
+ #if NPY_FEATURE_VERSION > NPY_2_3_API_VERSION
+    int same_value_casting = ((context->flags & NPY_SAME_VALUE_CASTING) == NPY_SAME_VALUE_CASTING);
+ #else
+    int same_value_casting = 0;
+ #endif
+#endif
 
     while (N--) {
 #if @aligned@
@@ -919,20 +940,35 @@ static GCC_CAST_OPT_LEVEL int
 #  if @is_complex2@
     dst_value[0] = _CONVERT_FN(src_value[0]);
     dst_value[1] = _CONVERT_FN(src_value[1]);
+    if (same_value_casting) {
+        if ((dst_value[0] != src_value[0]) || (dst_value[1] != src_value[1])){
+            return NPY_SAME_VALUE_FAILURE;
+        }
+    }
 #  elif !@aligned@
 #    if @is_bool2@
        dst_value = _CONVERT_FN(src_value[0]) || _CONVERT_FN(src_value[1]);
 #    else
        dst_value = _CONVERT_FN(src_value[0]);
+       if (same_value_casting) {
+           if (dst_value != src_value[0]){
+                return NPY_SAME_VALUE_FAILURE;
+            }
+       }
 #    endif
 #  else
 #    if @is_bool2@
        *(_TYPE2 *)dst = _CONVERT_FN(src_value[0]) || _CONVERT_FN(src_value[1]);
 #    else
        *(_TYPE2 *)dst = _CONVERT_FN(src_value[0]);
+       if (same_value_casting) {
+           if (*(_TYPE2 *)dst != src_value[0]){
+                return NPY_SAME_VALUE_FAILURE;
+            }
+       }
 #    endif
 #  endif
-#else
+#else // @is_complex1@
 #  if @is_complex2@
 #    if !@aligned@
     dst_value[0] = _CONVERT_FN(src_value);
@@ -940,10 +976,43 @@ static GCC_CAST_OPT_LEVEL int
     dst_value[0] = _CONVERT_FN(*(_TYPE1 *)src);
 #    endif
     dst_value[1] = 0;
+    if (same_value_casting) {
+#    if !@aligned@
+        if ((@rtype2@)dst_value[0] != src_value){
+#    else
+        if ((@rtype2@)dst_value[0] != *((_TYPE1 *)src)){
+#    endif
+            return NPY_SAME_VALUE_FAILURE;
+        }
+    }
 #  elif !@aligned@
     dst_value = _CONVERT_FN(src_value);
+#   if !@is_bool2@
+    if (same_value_casting) {
+        if (_TO_RTYPE1(src_value) > @type2max@) {
+            return NPY_SAME_VALUE_FAILURE;
+        }
+#       if !@is_unsigned1@
+        if (_TO_RTYPE1(src_value) < @type2min@) {
+            return NPY_SAME_VALUE_FAILURE;
+        }
+#       endif
+    }
+#   endif // @is_bool2@
 #  else
     *(_TYPE2 *)dst = _CONVERT_FN(*(_TYPE1 *)src);
+#   if !@is_bool2@
+    if (same_value_casting) {
+        if (_TO_RTYPE1(*((_TYPE1 *)src)) > @type2max@) {
+            return NPY_SAME_VALUE_FAILURE;
+        }
+#       if !@is_unsigned1@
+        if (_TO_RTYPE1(*((_TYPE1 *)src)) < @type2min@) {
+            return NPY_SAME_VALUE_FAILURE;
+        }
+#       endif
+    }
+#   endif // @is_bool2@
 #  endif
 #endif
 
@@ -981,6 +1050,7 @@ static GCC_CAST_OPT_LEVEL int
 #undef _CONVERT_FN
 #undef _TYPE2
 #undef _TYPE1
+#undef _TO_RTYPE1
 
 #endif
 
diff --git a/numpy/_core/src/multiarray/mapping.c b/numpy/_core/src/multiarray/mapping.c
index 7953e32fcbf0..74f0e87a1e3c 100644
--- a/numpy/_core/src/multiarray/mapping.c
+++ b/numpy/_core/src/multiarray/mapping.c
@@ -1241,6 +1241,9 @@ array_assign_boolean_subscript(PyArrayObject *self,
         }
 
         NPY_cast_info_xfree(&cast_info);
+        if (res < 0) {
+            HandleArrayMethodError(res, "cast", flags); 
+        }
         if (!NpyIter_Deallocate(iter)) {
             res = -1;
         }
@@ -2134,7 +2137,9 @@ array_assign_subscript(PyArrayObject *self, PyObject *ind, PyObject *op)
      * Could add a casting check, but apparently most assignments do
      * not care about safe casting.
      */
-    if (mapiter_set(mit, &cast_info, meth_flags, is_aligned) < 0) {
+    int result = mapiter_set(mit, &cast_info, meth_flags, is_aligned);
+    if (result < 0) {
+        HandleArrayMethodError(result, "cast", meth_flags); 
         goto fail;
     }
 
diff --git a/numpy/_core/src/multiarray/methods.c b/numpy/_core/src/multiarray/methods.c
index 58a554dc40be..b5dca76d18b8 100644
--- a/numpy/_core/src/multiarray/methods.c
+++ b/numpy/_core/src/multiarray/methods.c
@@ -840,7 +840,12 @@ array_astype(PyArrayObject *self,
         ((PyArrayObject_fields *)ret)->nd = PyArray_NDIM(self);
         ((PyArrayObject_fields *)ret)->descr = dtype;
     }
-    int success = PyArray_CopyInto(ret, self);
+    int success;
+    if (casting == NPY_SAME_VALUE_CASTING) {
+        success = PyArray_AssignArray(ret, self, NULL, casting);
+    } else {
+        success = PyArray_AssignArray(ret, self, NULL, NPY_UNSAFE_CASTING);
+    }
 
     Py_DECREF(dtype);
     ((PyArrayObject_fields *)ret)->nd = out_ndim;
diff --git a/numpy/_core/src/multiarray/multiarraymodule.c b/numpy/_core/src/multiarray/multiarraymodule.c
index 7724756ba351..a050ee8348ad 100644
--- a/numpy/_core/src/multiarray/multiarraymodule.c
+++ b/numpy/_core/src/multiarray/multiarraymodule.c
@@ -666,6 +666,12 @@ PyArray_ConcatenateInto(PyObject *op,
                 "argument, but both were provided.");
         return NULL;
     }
+    if (casting == NPY_SAME_VALUE_CASTING) {
+        PyErr_SetString(PyExc_NotImplementedError,
+            "concatenate with casting='same_value' not implemented yet");
+        return NULL;
+    }
+
 
     /* Convert the input list into arrays */
     narrays = PySequence_Size(op);
@@ -1940,6 +1946,11 @@ array_copyto(PyObject *NPY_UNUSED(ignored),
             NULL, NULL, NULL) < 0) {
         goto fail;
     }
+    if (casting == NPY_SAME_VALUE_CASTING) {
+        PyErr_SetString(PyExc_NotImplementedError,
+            "array_copyto with 'same_value' casting not implemented yet");
+        goto fail;
+    }
 
     if (!PyArray_Check(dst_obj)) {
         PyErr_Format(PyExc_TypeError,
diff --git a/numpy/_core/src/umath/legacy_array_method.c b/numpy/_core/src/umath/legacy_array_method.c
index 705262fedd38..7a85937fcc8f 100644
--- a/numpy/_core/src/umath/legacy_array_method.c
+++ b/numpy/_core/src/umath/legacy_array_method.c
@@ -439,11 +439,10 @@ PyArray_NewLegacyWrappingArrayMethod(PyUFuncObject *ufunc,
             descrs[i] = bound_res->dtypes[i]->singleton;
         }
 
-        PyArrayMethod_Context context = {
-                (PyObject *)ufunc,
-                bound_res->method,
-                descrs,
-        };
+        PyArrayMethod_Context context;
+        NPY_context_init(&context, descrs);
+        context.caller = (PyObject *)ufunc;
+        context.method = bound_res->method;
 
         int ret = get_initial_from_ufunc(&context, 0, context.method->legacy_initial);
 
diff --git a/numpy/_core/src/umath/reduction.c b/numpy/_core/src/umath/reduction.c
index b376b94936bc..384ac052b226 100644
--- a/numpy/_core/src/umath/reduction.c
+++ b/numpy/_core/src/umath/reduction.c
@@ -372,7 +372,7 @@ PyUFunc_ReduceWrapper(PyArrayMethod_Context *context,
                 PyArray_NDIM(result), PyArray_DIMS(result),
                 PyArray_DESCR(result),
                 PyArray_BYTES(result), PyArray_STRIDES(result),
-                op_dtypes[0], initial_buf);
+                op_dtypes[0], initial_buf, NPY_UNSAFE_CASTING);
         if (ret < 0) {
             goto fail;
         }
diff --git a/numpy/_core/src/umath/ufunc_object.c b/numpy/_core/src/umath/ufunc_object.c
index 4cdde8d3d77d..93701738300e 100644
--- a/numpy/_core/src/umath/ufunc_object.c
+++ b/numpy/_core/src/umath/ufunc_object.c
@@ -2084,11 +2084,10 @@ PyUFunc_GeneralizedFunctionInternal(PyUFuncObject *ufunc,
                                     NPY_SIZEOF_INTP * nop);
 
     /* Final preparation of the arraymethod call */
-    PyArrayMethod_Context context = {
-        .caller = (PyObject *)ufunc,
-        .method = ufuncimpl,
-        .descriptors = operation_descrs,
-    };
+    PyArrayMethod_Context context;
+    NPY_context_init(&context, operation_descrs);
+    context.caller = (PyObject *)ufunc;
+    context.method = ufuncimpl;
     PyArrayMethod_StridedLoop *strided_loop;
     NPY_ARRAYMETHOD_FLAGS flags = 0;
 
@@ -2203,11 +2202,10 @@ PyUFunc_GenericFunctionInternal(PyUFuncObject *ufunc,
     }
 
     /* Final preparation of the arraymethod call */
-    PyArrayMethod_Context context = {
-        .caller = (PyObject *)ufunc,
-        .method = ufuncimpl,
-        .descriptors = operation_descrs,
-    };
+    PyArrayMethod_Context context;
+    NPY_context_init(&context, operation_descrs);
+    context.caller = (PyObject *)ufunc;
+    context.method = ufuncimpl;
 
     /* Do the ufunc loop */
     if (wheremask != NULL) {
@@ -2553,11 +2551,10 @@ PyUFunc_Reduce(PyUFuncObject *ufunc,
         return NULL;
     }
 
-    PyArrayMethod_Context context = {
-        .caller = (PyObject *)ufunc,
-        .method = ufuncimpl,
-        .descriptors = descrs,
-    };
+    PyArrayMethod_Context context;
+    NPY_context_init(&context, descrs);
+    context.caller = (PyObject *)ufunc;
+    context.method = ufuncimpl;
 
     PyArrayObject *result = PyUFunc_ReduceWrapper(&context,
             arr, out, wheremask, axis_flags, keepdims,
@@ -2629,12 +2626,10 @@ PyUFunc_Accumulate(PyUFuncObject *ufunc, PyArrayObject *arr, PyArrayObject *out,
     assert(PyArray_EquivTypes(descrs[0], descrs[1])
            && PyArray_EquivTypes(descrs[0], descrs[2]));
 
-    PyArrayMethod_Context context = {
-        .caller = (PyObject *)ufunc,
-        .method = ufuncimpl,
-        .descriptors = descrs,
-    };
-
+    PyArrayMethod_Context context;
+    NPY_context_init(&context, descrs);
+    context.caller = (PyObject *)ufunc,
+    context.method = ufuncimpl,
     ndim = PyArray_NDIM(arr);
 
 #if NPY_UF_DBG_TRACING
@@ -3061,12 +3056,10 @@ PyUFunc_Reduceat(PyUFuncObject *ufunc, PyArrayObject *arr, PyArrayObject *ind,
         goto fail;
     }
 
-    PyArrayMethod_Context context = {
-        .caller = (PyObject *)ufunc,
-        .method = ufuncimpl,
-        .descriptors = descrs,
-    };
-
+    PyArrayMethod_Context context;
+    NPY_context_init(&context, descrs);
+    context.caller = (PyObject *)ufunc,
+    context.method = ufuncimpl,
     ndim = PyArray_NDIM(arr);
 
 #if NPY_UF_DBG_TRACING
@@ -4533,6 +4526,10 @@ ufunc_generic_fastcall(PyUFuncObject *ufunc,
             full_args.in, casting) < 0) {
         goto fail;
     }
+    if (casting == NPY_SAME_VALUE_CASTING) {
+        PyErr_SetString(PyExc_NotImplementedError,
+            "ufunc with 'same_value' casting not implemented yet");
+    }
 
     /*
      * Do the final preparations and call the inner-loop.
@@ -5897,11 +5894,10 @@ ufunc_at(PyUFuncObject *ufunc, PyObject *args)
         }
     }
 
-    PyArrayMethod_Context context = {
-            .caller = (PyObject *)ufunc,
-            .method = ufuncimpl,
-            .descriptors = operation_descrs,
-    };
+    PyArrayMethod_Context context;
+    NPY_context_init(&context, operation_descrs);
+    context.caller = (PyObject *)ufunc;
+    context.method = ufuncimpl;
 
     /* Use contiguous strides; if there is such a loop it may be faster */
     npy_intp strides[3] = {
diff --git a/numpy/_core/tests/test_casting_unittests.py b/numpy/_core/tests/test_casting_unittests.py
index f8441ea9d0d7..3d9d7e6243d0 100644
--- a/numpy/_core/tests/test_casting_unittests.py
+++ b/numpy/_core/tests/test_casting_unittests.py
@@ -10,13 +10,14 @@
 import enum
 import random
 import textwrap
+import warnings
 
 import pytest
 from numpy._core._multiarray_umath import _get_castingimpl as get_castingimpl
 
 import numpy as np
 from numpy.lib.stride_tricks import as_strided
-from numpy.testing import assert_array_equal
+from numpy.testing import assert_array_equal, assert_equal
 
 # Simple skips object, parametric and long double (unsupported by struct)
 simple_dtypes = "?bhilqBHILQefdFD"
@@ -76,6 +77,7 @@ class Casting(enum.IntEnum):
     safe = 2
     same_kind = 3
     unsafe = 4
+    same_value = 5
 
 
 def _get_cancast_table():
@@ -304,6 +306,7 @@ def test_simple_direct_casts(self, from_dt):
             to_dt = to_dt.values[0]
             cast = get_castingimpl(type(from_dt), type(to_dt))
 
+            print("from_dt", from_dt, "to_dt", to_dt)
             casting, (from_res, to_res), view_off = cast._resolve_descriptors(
                 (from_dt, to_dt))
 
@@ -317,7 +320,9 @@ def test_simple_direct_casts(self, from_dt):
 
             arr1, arr2, values = self.get_data(from_dt, to_dt)
 
+            print("2", arr1, arr2, cast)
             cast._simple_strided_call((arr1, arr2))
+            print("3")
 
             # Check via python list
             assert arr2.tolist() == values
@@ -815,3 +820,58 @@ def test_nonstandard_bool_to_other(self, dtype):
         res = nonstandard_bools.astype(dtype)
         expected = [0, 1, 1]
         assert_array_equal(res, expected)
+
+    @pytest.mark.parametrize("to_dtype",
+            np.typecodes["AllInteger"] + np.typecodes["AllFloat"])
+    @pytest.mark.parametrize("from_dtype",
+            np.typecodes["AllInteger"] + np.typecodes["AllFloat"])
+    def test_same_value(self, from_dtype, to_dtype):
+        if from_dtype == to_dtype:
+            return
+        top1 = 0
+        top2 = 0
+        try:
+            top1 = np.iinfo(from_dtype).max
+        except ValueError:
+            top1 = np.finfo(from_dtype).max
+        try:
+            top2 = np.iinfo(to_dtype).max
+        except ValueError:
+            top2 = np.finfo(to_dtype).max
+        # No need to test if top2 > top1, since the test will also do the
+        # reverse dtype matching. Catch then warning if the comparison warns,
+        # i.e. np.int16(65535) < np.float16(6.55e4)
+        with warnings.catch_warnings(record=True):
+            warnings.simplefilter("always", RuntimeWarning)
+            if top2 >= top1:
+                # will be tested when the dtypes are reversed
+                return
+        # Happy path
+        arr1 = np.array([0] * 10, dtype=from_dtype)
+        arr2 = np.array([0] * 10, dtype=to_dtype)
+        with warnings.catch_warnings(record=True) as w:
+            # complex -> non-complex will warn
+            warnings.simplefilter("always", RuntimeWarning)
+            arr1_astype = arr1.astype(to_dtype, casting='same_value')
+        assert_equal(arr1_astype, arr2, strict=True)
+        # Make it overflow, both aligned and unaligned
+        arr1[0] = top1
+        aligned = np.empty(arr1.itemsize * arr1.size + 1, 'uint8')
+        unaligned = aligned[1:].view(arr1.dtype)
+        unaligned[:] = arr1
+        with pytest.raises(ValueError):
+            # Casting float to float with overflow should raise
+            # RuntimeWarning (fperror)
+            # Casting float to int with overflow sometimes raises
+            # RuntimeWarning (fperror)
+            # Casting with overflow  and 'same_value', should raise ValueError
+            with warnings.catch_warnings(record=True) as w:
+                warnings.simplefilter("always", RuntimeWarning)
+                arr1.astype(to_dtype, casting='same_value')
+            assert len(w) < 2
+        with pytest.raises(ValueError):
+            # again, unaligned
+            with warnings.catch_warnings(record=True) as w:
+                warnings.simplefilter("always", RuntimeWarning)
+                unaligned.astype(to_dtype, casting='same_value')
+            assert len(w) < 2
diff --git a/numpy/_core/tests/test_datetime.py b/numpy/_core/tests/test_datetime.py
index 1cbacb8a26a8..992e455ac7f5 100644
--- a/numpy/_core/tests/test_datetime.py
+++ b/numpy/_core/tests/test_datetime.py
@@ -1840,6 +1840,10 @@ def test_datetime_as_string(self):
                             '2032-07-18')
         assert_equal(np.datetime_as_string(a, unit='D', casting='unsafe'),
                             '2032-07-18')
+
+        with pytest.raises(TypeError):
+            np.datetime_as_string(a, unit='Y', casting='same_value')
+
         assert_equal(np.datetime_as_string(a, unit='h'), '2032-07-18T12')
         assert_equal(np.datetime_as_string(a, unit='m'),
                             '2032-07-18T12:23')
diff --git a/numpy/_core/tests/test_einsum.py b/numpy/_core/tests/test_einsum.py
index 0bd180b5e41f..8954e8a6c0d4 100644
--- a/numpy/_core/tests/test_einsum.py
+++ b/numpy/_core/tests/test_einsum.py
@@ -79,6 +79,11 @@ def test_einsum_errors(self, do_opt, einsum_fn):
             b = np.ones((3, 4, 5))
             einsum_fn('aabcb,abc', a, b)
 
+        with pytest.raises(NotImplementedError):
+            a = np.arange(3)
+            # einsum_path does not accept kwarg 'casting'
+            np.einsum('ij->j', [a, a], casting='same_value')
+
     def test_einsum_sorting_behavior(self):
         # Case 1: 26 dimensions (all lowercase indices)
         n1 = 26
diff --git a/numpy/_core/tests/test_shape_base.py b/numpy/_core/tests/test_shape_base.py
index f7b944be08b7..b1e4caebe8e3 100644
--- a/numpy/_core/tests/test_shape_base.py
+++ b/numpy/_core/tests/test_shape_base.py
@@ -365,6 +365,11 @@ def test_concatenate(self):
         assert_(out is rout)
         assert_equal(res, rout)
 
+    def test_concatenate_same_value(self):
+        r4 = list(range(4))
+        with pytest.raises(NotImplementedError):
+            concatenate([r4, r4], casting="same_value")
+
     @pytest.mark.skipif(IS_PYPY, reason="PYPY handles sq_concat, nb_add differently than cpython")
     def test_operator_concat(self):
         import operator