diff --git a/Lib/test/test_capi/test_float.py b/Lib/test/test_capi/test_float.py
index 8b25607b6d504f7..91da2cf5ee9f616 100644
--- a/Lib/test/test_capi/test_float.py
+++ b/Lib/test/test_capi/test_float.py
@@ -226,6 +226,8 @@ def test_pack_unpack_roundtrip_for_nans(self):
                         value = unpack(data1, endian)
                         data2 = pack(size, value, endian)
                         self.assertTrue(math.isnan(value))
+                        self.assertEqual(math.copysign(1.0, value),
+                                         -1.0 if sign else 1.0)
                         self.assertEqual(data1, data2)
 
     @unittest.skipUnless(HAVE_IEEE_754, "requires IEEE 754")
diff --git a/Misc/NEWS.d/next/C_API/2026-07-28-04-29-52.gh-issue-153740.7_LMSA.rst b/Misc/NEWS.d/next/C_API/2026-07-28-04-29-52.gh-issue-153740.7_LMSA.rst
new file mode 100644
index 000000000000000..f01009f10e9b5b1
--- /dev/null
+++ b/Misc/NEWS.d/next/C_API/2026-07-28-04-29-52.gh-issue-153740.7_LMSA.rst
@@ -0,0 +1,3 @@
+If available on the platform, use native :c:type:`_Float16` in
+:c:func:`PyFloat_Pack2` and :c:func:`PyFloat_Unpack2` functions.  Patch by
+Sergey B Kirpichev.
diff --git a/Objects/floatobject.c b/Objects/floatobject.c
index 17e6a729dcd83fc..3d32f6a11d90b30 100644
--- a/Objects/floatobject.c
+++ b/Objects/floatobject.c
@@ -1894,6 +1894,69 @@ _PyFloat_DebugMallocStats(FILE *out)
 int
 PyFloat_Pack2(double x, char *data, int le)
 {
+#if HAVE_FLOAT16
+    unsigned char *p = (unsigned char *)data;
+    _Float16 y = (_Float16)x;
+    int i, incr = 1;
+
+    if (isinf(y) && !isinf(x)) {
+        PyErr_SetString(PyExc_OverflowError,
+                        "float too large to pack with e format");
+        return -1;
+    }
+
+    /* correct y if x was a sNaN, transformed to qNaN by conversion */
+    if (isnan(x)) {
+        uint64_t v;
+
+        memcpy(&v, &x, 8);
+#ifndef __riscv
+        if ((v & (1ULL << 51)) == 0) {
+            uint16_t u16;
+            memcpy(&u16, &y, 2);
+            /* if have payload, make sNaN */
+            if (u16 & 0x1ff) {
+                u16 &= ~(1 << 9);
+            }
+            memcpy(&y, &u16, 2);
+        }
+#else
+        uint16_t u16;
+
+        memcpy(&u16, &y, 2);
+        /* Workaround RISC-V: "If a NaN value is converted to a
+         * different floating-point type, the result is the
+         * canonical NaN of the new type".  The canonical NaN here
+         * is a positive qNaN with zero payload. */
+        if (v & (1ULL << 63)) {
+            u16 |= (uint16_t)(1U << 15); /* set sign */
+        }
+        /* add payload */
+        u16 -= (u16 & 0x1ff);
+        u16 += (uint16_t)((v & 0x7ffffffffffffULL) >> 42);
+        /* if have payload, make sNaN */
+        if ((v & (1ULL << 51)) == 0 && (u16 & 0x1ff)) {
+            u16 &= ~(1 << 9);
+        }
+
+        memcpy(&y, &u16, 2);
+#endif
+    }
+
+    unsigned char s[sizeof(_Float16)];
+    memcpy(s, &y, sizeof(_Float16));
+
+    if ((_PY_FLOAT_LITTLE_ENDIAN && !le) || (_PY_FLOAT_BIG_ENDIAN && le)) {
+        p += 1;
+        incr = -1;
+    }
+
+    for (i = 0; i < 2; i++) {
+        *p = s[i];
+        p += incr;
+    }
+    return 0;
+#else
     unsigned char *p = (unsigned char *)data;
     unsigned char sign;
     int e;
@@ -1997,6 +2060,7 @@ PyFloat_Pack2(double x, char *data, int le)
     PyErr_SetString(PyExc_OverflowError,
                     "float too large to pack with e format");
     return -1;
+#endif /* HAVE_FLOAT16 */
 }
 
 int
@@ -2089,6 +2153,63 @@ PyFloat_Pack8(double x, char *data, int le)
 double
 PyFloat_Unpack2(const char *data, int le)
 {
+#if HAVE_FLOAT16
+    unsigned char *p = (unsigned char *)data;
+    _Float16 x;
+
+    if ((_PY_FLOAT_LITTLE_ENDIAN && !le) || (_PY_FLOAT_BIG_ENDIAN && le)) {
+        char buf[2];
+        char *d = &buf[1];
+        int i;
+
+        for (i = 0; i < 2; i++) {
+            *d-- = *p++;
+        }
+        memcpy(&x, buf, 2);
+    }
+    else {
+        memcpy(&x, p, 2);
+    }
+
+    /* return sNaN double if x was sNaN float */
+    if (isnan(x)) {
+        uint16_t v;
+        memcpy(&v, &x, 2);
+
+#ifndef __riscv
+        if ((v & (1 << 9)) == 0) {
+            double y = x; /* will make qNaN double */
+            uint64_t u64;
+
+            memcpy(&u64, &y, 8);
+            u64 &= ~(1ULL << 51); /* make sNaN */
+            memcpy(&y, &u64, 8);
+            return y;
+        }
+
+#else
+        double y = x;
+        uint64_t u64;
+
+        memcpy(&u64, &y, 8);
+        if ((v & (1 << 9)) == 0) {
+            u64 &= ~(1ULL << 51);
+        }
+        /* Workaround RISC-V, see PyFloat_Pack4() */
+        if (v & (1U << 15)) {
+            u64 |= (1ULL << 63); /* set sign */
+        }
+        /* add payload */
+        u64 -= (u64 & 0x7ffffffffffffULL);
+        u64 += ((v & 0x1ffULL) << 42);
+
+        memcpy(&y, &u64, 8);
+        return y;
+#endif
+    }
+
+    return x;
+#else
     unsigned char *p = (unsigned char *)data;
     unsigned char sign;
     int e;
@@ -2140,6 +2261,7 @@ PyFloat_Unpack2(const char *data, int le)
         x = -x;
 
     return x;
+#endif /* HAVE_FLOAT16 */
 }
 
 double
diff --git a/configure b/configure
index 2c82da923f68d4a..47a78bbd2e6d578 100755
--- a/configure
+++ b/configure
@@ -16705,6 +16705,65 @@ printf "%s\n" "#define _Py_FFI_SUPPORT_C_COMPLEX 1" >>confdefs.h
 
 fi
 
+# Check for native half-float type.
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for _Float16 support" >&5
+printf %s "checking for _Float16 support... " >&6; }
+if test ${ac_cv_float16_supported+y}
+then :
+  printf %s "(cached) " >&6
+else case e in #(
+  e) save_CFLAGS=$CFLAGS
+save_CPPFLAGS=$CPPFLAGS
+save_LDFLAGS=$LDFLAGS
+save_LIBS=$LIBS
+
+
+CFLAGS="$CFLAGS -O0"
+if test "$cross_compiling" = yes
+then :
+  ac_cv_float16_supported=no
+else case e in #(
+  e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int main(void)
+{
+    _Float16 val = 1.0f16;
+    double d = 3.14;
+    val = d;
+    return 0;
+}
+
+_ACEOF
+if ac_fn_c_try_run "$LINENO"
+then :
+  ac_cv_float16_supported=yes
+else case e in #(
+  e) ac_cv_float16_supported=no ;;
+esac
+fi
+rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
+  conftest.$ac_objext conftest.beam conftest.$ac_ext ;;
+esac
+fi
+
+CFLAGS=$save_CFLAGS
+CPPFLAGS=$save_CPPFLAGS
+LDFLAGS=$save_LDFLAGS
+LIBS=$save_LIBS
+
+ ;;
+esac
+fi
+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_float16_supported" >&5
+printf "%s\n" "$ac_cv_float16_supported" >&6; }
+if test "x$ac_cv_float16_supported" = xyes
+then :
+
+printf "%s\n" "#define HAVE_FLOAT16 1" >>confdefs.h
+
+fi
+
 
 pkg_failed=no
 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for libmpdec >= 2.5.0" >&5
diff --git a/configure.ac b/configure.ac
index 771260c76b7f094..8189379b70f7a52 100644
--- a/configure.ac
+++ b/configure.ac
@@ -4462,6 +4462,25 @@ if test "$ac_cv_ffi_complex_double_supported" = "yes"; then
               [Defined if _Complex C type can be used with libffi.])
 fi
 
+# Check for native half-float type.
+AC_CACHE_CHECK([for _Float16 support], [ac_cv_float16_supported],
+WITH_SAVE_ENV([
+CFLAGS="$CFLAGS -O0"
+AC_RUN_IFELSE([AC_LANG_SOURCE([[
+int main(void)
+{
+    _Float16 val = 1.0f16;
+    double d = 3.14;
+    val = d;
+    return 0;
+}
+]])], [ac_cv_float16_supported=yes],
+[ac_cv_float16_supported=no],
+[ac_cv_float16_supported=no])]))
+AS_VAR_IF([ac_cv_float16_supported], [yes],
+          [AC_DEFINE([HAVE_FLOAT16], [1],
+                     [Defined if _Float16 C type is supported])])
+
 dnl Check for libmpdec >= 2.5.0
 PKG_CHECK_MODULES([LIBMPDEC], [libmpdec >= 2.5.0], [have_mpdec=yes], [
   WITH_SAVE_ENV([
diff --git a/pyconfig.h.in b/pyconfig.h.in
index 691c6c0d9feb6d0..6b7eec66371fbeb 100644
--- a/pyconfig.h.in
+++ b/pyconfig.h.in
@@ -497,6 +497,9 @@
 /* Define if you have the 'ffi_prep_closure_loc' function. */
 #undef HAVE_FFI_PREP_CLOSURE_LOC
 
+/* Defined if _Float16 C type is supported */
+#undef HAVE_FLOAT16
+
 /* Define to 1 if you have the 'flock' function. */
 #undef HAVE_FLOCK