diff --git a/newsfragments/6022.added.md b/newsfragments/6022.added.md
new file mode 100644
index 00000000000..21682bcec85
--- /dev/null
+++ b/newsfragments/6022.added.md
@@ -0,0 +1 @@
+Made `pyo3-ffi` crate `no_std`.
diff --git a/pyo3-ffi/src/abstract_.rs b/pyo3-ffi/src/abstract_.rs
index c2b141b0c6e..fe04b66e62f 100644
--- a/pyo3-ffi/src/abstract_.rs
+++ b/pyo3-ffi/src/abstract_.rs
@@ -1,8 +1,8 @@
 use crate::object::*;
 use crate::pyport::Py_ssize_t;
+use core::ffi::{c_char, c_int};
 #[cfg(any(Py_3_12, not(Py_LIMITED_API)))]
 use libc::size_t;
-use std::ffi::{c_char, c_int};
 
 #[inline]
 #[cfg(all(
@@ -10,7 +10,7 @@ use std::ffi::{c_char, c_int};
     not(all(PyPy, not(Py_3_11))) // PyPy exposed as a function until PyPy 3.10, macro in 3.11+
 ))]
 pub unsafe fn PyObject_DelAttrString(o: *mut PyObject, attr_name: *const c_char) -> c_int {
-    PyObject_SetAttrString(o, attr_name, std::ptr::null_mut())
+    PyObject_SetAttrString(o, attr_name, core::ptr::null_mut())
 }
 
 #[inline]
@@ -19,7 +19,7 @@ pub unsafe fn PyObject_DelAttrString(o: *mut PyObject, attr_name: *const c_char)
     not(all(PyPy, not(Py_3_11))) // PyPy exposed as a function until PyPy 3.10, macro in 3.11+
 ))]
 pub unsafe fn PyObject_DelAttr(o: *mut PyObject, attr_name: *mut PyObject) -> c_int {
-    PyObject_SetAttr(o, attr_name, std::ptr::null_mut())
+    PyObject_SetAttr(o, attr_name, core::ptr::null_mut())
 }
 
 extern_libpython! {
@@ -86,7 +86,7 @@ extern_libpython! {
 
 #[cfg(any(Py_3_12, not(Py_LIMITED_API)))]
 pub const PY_VECTORCALL_ARGUMENTS_OFFSET: size_t = (1 as size_t)
-    .checked_shl((8 * std::mem::size_of::<size_t>() - 1) as u32)
+    .checked_shl((8 * core::mem::size_of::<size_t>() - 1) as u32)
     .expect("size_t should fit the flag bits");
 
 extern_libpython! {
diff --git a/pyo3-ffi/src/boolobject.rs b/pyo3-ffi/src/boolobject.rs
index 5294756cb88..bf55c1dedc6 100644
--- a/pyo3-ffi/src/boolobject.rs
+++ b/pyo3-ffi/src/boolobject.rs
@@ -1,7 +1,7 @@
 #[cfg(all(not(GraalPy), not(all(Py_3_13, Py_LIMITED_API))))]
 use crate::longobject::PyLongObject;
 use crate::object::*;
-use std::ffi::{c_int, c_long};
+use core::ffi::{c_int, c_long};
 
 #[inline]
 #[cfg(not(RustPython))]
diff --git a/pyo3-ffi/src/bytearrayobject.rs b/pyo3-ffi/src/bytearrayobject.rs
index 95db8c1e590..713a352c530 100644
--- a/pyo3-ffi/src/bytearrayobject.rs
+++ b/pyo3-ffi/src/bytearrayobject.rs
@@ -1,6 +1,6 @@
 use crate::object::*;
 use crate::pyport::Py_ssize_t;
-use std::ffi::{c_char, c_int};
+use core::ffi::{c_char, c_int};
 
 #[cfg(not(RustPython))]
 extern_libpython! {
diff --git a/pyo3-ffi/src/bytesobject.rs b/pyo3-ffi/src/bytesobject.rs
index dd966807996..c99e0dabefa 100644
--- a/pyo3-ffi/src/bytesobject.rs
+++ b/pyo3-ffi/src/bytesobject.rs
@@ -1,6 +1,6 @@
 use crate::object::*;
 use crate::pyport::Py_ssize_t;
-use std::ffi::{c_char, c_int};
+use core::ffi::{c_char, c_int};
 
 #[cfg(not(RustPython))]
 extern_libpython! {
diff --git a/pyo3-ffi/src/ceval.rs b/pyo3-ffi/src/ceval.rs
index 83814ada606..37294d7e59b 100644
--- a/pyo3-ffi/src/ceval.rs
+++ b/pyo3-ffi/src/ceval.rs
@@ -1,6 +1,6 @@
 use crate::object::PyObject;
 use crate::pytypedefs::PyThreadState;
-use std::ffi::{c_char, c_int, c_void};
+use core::ffi::{c_char, c_int, c_void};
 
 extern_libpython! {
     #[cfg_attr(PyPy, link_name = "PyPyEval_EvalCode")]
@@ -39,7 +39,7 @@ extern_libpython! {
 #[inline]
 pub unsafe fn PyEval_CallObject(func: *mut PyObject, arg: *mut PyObject) -> *mut PyObject {
     #[allow(deprecated)]
-    PyEval_CallObjectWithKeywords(func, arg, std::ptr::null_mut())
+    PyEval_CallObjectWithKeywords(func, arg, core::ptr::null_mut())
 }
 
 extern_libpython! {
diff --git a/pyo3-ffi/src/codecs.rs b/pyo3-ffi/src/codecs.rs
index bf397cd0584..4d53f4e354f 100644
--- a/pyo3-ffi/src/codecs.rs
+++ b/pyo3-ffi/src/codecs.rs
@@ -1,5 +1,5 @@
 use crate::object::PyObject;
-use std::ffi::{c_char, c_int};
+use core::ffi::{c_char, c_int};
 
 extern_libpython! {
     pub fn PyCodec_Register(search_function: *mut PyObject) -> c_int;
diff --git a/pyo3-ffi/src/compat/py_3_10.rs b/pyo3-ffi/src/compat/py_3_10.rs
index 2d4daa194c6..5c931de4d85 100644
--- a/pyo3-ffi/src/compat/py_3_10.rs
+++ b/pyo3-ffi/src/compat/py_3_10.rs
@@ -24,9 +24,9 @@ compat_function!(
     #[inline]
     pub unsafe fn PyModule_AddObjectRef(
         module: *mut crate::PyObject,
-        name: *const std::ffi::c_char,
+        name: *const core::ffi::c_char,
         value: *mut crate::PyObject,
-    ) -> std::ffi::c_int {
+    ) -> core::ffi::c_int {
         if value.is_null() && crate::PyErr_Occurred().is_null() {
             crate::PyErr_SetString(
                 crate::PyExc_SystemError,
diff --git a/pyo3-ffi/src/compat/py_3_13.rs b/pyo3-ffi/src/compat/py_3_13.rs
index 7c30ea9843a..c2030d98e25 100644
--- a/pyo3-ffi/src/compat/py_3_13.rs
+++ b/pyo3-ffi/src/compat/py_3_13.rs
@@ -6,7 +6,7 @@ compat_function!(
         dp: *mut crate::PyObject,
         key: *mut crate::PyObject,
         result: *mut *mut crate::PyObject,
-    ) -> std::ffi::c_int {
+    ) -> core::ffi::c_int {
         use crate::{compat::Py_NewRef, PyDict_GetItemWithError, PyErr_Occurred};
 
         let item = PyDict_GetItemWithError(dp, key);
@@ -14,7 +14,7 @@ compat_function!(
             *result = Py_NewRef(item);
             return 1; // found
         }
-        *result = std::ptr::null_mut();
+        *result = core::ptr::null_mut();
         if PyErr_Occurred().is_null() {
             return 0; // not found
         }
@@ -43,7 +43,7 @@ compat_function!(
 
     #[inline]
     pub unsafe fn PyImport_AddModuleRef(
-        name: *const std::ffi::c_char,
+        name: *const core::ffi::c_char,
     ) -> *mut crate::PyObject {
         use crate::{compat::Py_XNewRef, PyImport_AddModule};
 
@@ -58,25 +58,25 @@ compat_function!(
     pub unsafe fn PyWeakref_GetRef(
         reference: *mut crate::PyObject,
         pobj: *mut *mut crate::PyObject,
-    ) -> std::ffi::c_int {
+    ) -> core::ffi::c_int {
         use crate::{
             compat::Py_NewRef, PyErr_SetString, PyExc_TypeError, PyWeakref_Check,
             PyWeakref_GetObject, Py_None,
         };
 
         if !reference.is_null() && PyWeakref_Check(reference) == 0 {
-            *pobj = std::ptr::null_mut();
+            *pobj = core::ptr::null_mut();
             PyErr_SetString(PyExc_TypeError, c"expected a weakref".as_ptr());
             return -1;
         }
         let obj = PyWeakref_GetObject(reference);
         if obj.is_null() {
             // SystemError if reference is NULL
-            *pobj = std::ptr::null_mut();
+            *pobj = core::ptr::null_mut();
             return -1;
         }
         if obj == Py_None() {
-            *pobj = std::ptr::null_mut();
+            *pobj = core::ptr::null_mut();
             return 0;
         }
         *pobj = Py_NewRef(obj);
@@ -91,7 +91,7 @@ compat_function!(
     pub unsafe fn PyList_Extend(
         list: *mut crate::PyObject,
         iterable: *mut crate::PyObject,
-    ) -> std::ffi::c_int {
+    ) -> core::ffi::c_int {
         crate::PyList_SetSlice(list, crate::PY_SSIZE_T_MAX, crate::PY_SSIZE_T_MAX, iterable)
     }
 );
@@ -100,8 +100,8 @@ compat_function!(
     originally_defined_for(Py_3_13);
 
     #[inline]
-    pub unsafe fn PyList_Clear(list: *mut crate::PyObject) -> std::ffi::c_int {
-        crate::PyList_SetSlice(list, 0, crate::PY_SSIZE_T_MAX, std::ptr::null_mut())
+    pub unsafe fn PyList_Clear(list: *mut crate::PyObject) -> core::ffi::c_int {
+        crate::PyList_SetSlice(list, 0, crate::PY_SSIZE_T_MAX, core::ptr::null_mut())
     }
 );
 
@@ -111,9 +111,9 @@ compat_function!(
     #[inline]
     pub unsafe fn PyModule_Add(
         module: *mut crate::PyObject,
-        name: *const std::ffi::c_char,
+        name: *const core::ffi::c_char,
         value: *mut crate::PyObject,
-    ) -> std::ffi::c_int {
+    ) -> core::ffi::c_int {
         let result = crate::compat::PyModule_AddObjectRef(module, name, value);
         crate::Py_XDECREF(value);
         result
@@ -140,16 +140,16 @@ compat_function!(
         key: *mut crate::PyObject,
         default_value: *mut crate::PyObject,
         result: *mut *mut crate::PyObject,
-    ) -> std::ffi::c_int {
+    ) -> core::ffi::c_int {
         use crate::{
             compat::{PyDict_GetItemRef, Py_NewRef},
             PyDict_SetItem, PyObject, Py_DECREF,
         };
-        let mut value: *mut PyObject = std::ptr::null_mut();
+        let mut value: *mut PyObject = core::ptr::null_mut();
         if PyDict_GetItemRef(mp, key, &mut value) < 0 {
             // get error
             if !result.is_null() {
-                *result = std::ptr::null_mut();
+                *result = core::ptr::null_mut();
             }
             return -1;
         }
@@ -167,7 +167,7 @@ compat_function!(
         if PyDict_SetItem(mp, key, default_value) < 0 {
             // set error
             if !result.is_null() {
-                *result = std::ptr::null_mut();
+                *result = core::ptr::null_mut();
             }
             return -1;
         }
@@ -186,7 +186,7 @@ compat_function!(
         obj: *mut crate::PyObject,
         name: *mut crate::PyObject,
         result: *mut *mut crate::PyObject,
-    ) -> std::ffi::c_int {
+    ) -> core::ffi::c_int {
         use crate::{PyErr_Clear, PyErr_ExceptionMatches, PyExc_AttributeError, PyObject_GetAttr};
 
         let attr = PyObject_GetAttr(obj, name);
@@ -194,7 +194,7 @@ compat_function!(
             *result = attr;
             return 1; // found
         }
-        *result = std::ptr::null_mut();
+        *result = core::ptr::null_mut();
         if PyErr_ExceptionMatches(PyExc_AttributeError) != 0 {
             PyErr_Clear();
             return 0; // not found
@@ -207,8 +207,8 @@ compat_function!(
     originally_defined_for(Py_3_13);
 
     #[inline]
-    pub unsafe fn PyObject_HasAttrWithError(obj: *mut crate::PyObject, attr_name: *mut crate::PyObject) -> std::ffi::c_int {
-        let mut res: *mut crate::PyObject = std::ptr::null_mut();
+    pub unsafe fn PyObject_HasAttrWithError(obj: *mut crate::PyObject, attr_name: *mut crate::PyObject) -> core::ffi::c_int {
+        let mut res: *mut crate::PyObject = core::ptr::null_mut();
         let rc = crate::compat::PyObject_GetOptionalAttr(obj, attr_name, &mut res);
         crate::Py_XDECREF(res);
         rc
diff --git a/pyo3-ffi/src/compat/py_3_14.rs b/pyo3-ffi/src/compat/py_3_14.rs
index 28cef7975c9..879ec93e77e 100644
--- a/pyo3-ffi/src/compat/py_3_14.rs
+++ b/pyo3-ffi/src/compat/py_3_14.rs
@@ -3,7 +3,7 @@ compat_function!(
 
     #[inline]
     pub unsafe fn Py_HashBuffer(
-        ptr: *const std::ffi::c_void,
+        ptr: *const core::ffi::c_void,
         len: crate::Py_ssize_t,
     ) -> crate::Py_hash_t {
         #[cfg(not(any(Py_LIMITED_API, PyPy)))]
@@ -13,7 +13,7 @@ compat_function!(
 
         #[cfg(any(Py_LIMITED_API, PyPy))]
         {
-            let bytes = crate::PyBytes_FromStringAndSize(ptr as *const std::ffi::c_char, len);
+            let bytes = crate::PyBytes_FromStringAndSize(ptr as *const core::ffi::c_char, len);
             if bytes.is_null() {
                 -1
             } else {
@@ -32,7 +32,7 @@ compat_function!(
     pub unsafe fn PyIter_NextItem(
         iter: *mut crate::PyObject,
         item: *mut *mut crate::PyObject,
-    ) -> std::ffi::c_int {
+    ) -> core::ffi::c_int {
         *item = crate::PyIter_Next(iter);
         if !(*item).is_null() {
             1
diff --git a/pyo3-ffi/src/compat/py_3_15.rs b/pyo3-ffi/src/compat/py_3_15.rs
index 052fd9fd481..c3efc30e054 100644
--- a/pyo3-ffi/src/compat/py_3_15.rs
+++ b/pyo3-ffi/src/compat/py_3_15.rs
@@ -12,22 +12,22 @@ compat_function!(
 
         if size < 0 {
             crate::PyErr_SetString(crate::PyExc_ValueError, c"size must be >= 0".as_ptr() as *const _);
-            return std::ptr::null_mut();
+            return core::ptr::null_mut();
         }
 
-        let writer: *mut PyBytesWriter = crate::PyMem_Malloc(std::mem::size_of::<PyBytesWriter>()).cast();
+        let writer: *mut PyBytesWriter = crate::PyMem_Malloc(core::mem::size_of::<PyBytesWriter>()).cast();
         if writer.is_null() {
             crate::PyErr_NoMemory();
-            return std::ptr::null_mut();
+            return core::ptr::null_mut();
         }
 
-        (*writer).obj = std::ptr::null_mut();
+        (*writer).obj = core::ptr::null_mut();
         (*writer).size = 0;
 
         if size >=1 {
             if _PyBytesWriter_Resize_impl(writer, size, 0) < 0 {
                 PyBytesWriter_Discard(writer);
-                return std::ptr::null_mut();
+                return core::ptr::null_mut();
             }
 
             (*writer).size = size;
@@ -75,9 +75,9 @@ compat_function!(
         } else {
             if size != crate::PyBytes_Size((*writer).obj) && crate::_PyBytes_Resize(&mut (*writer).obj, size) < 0 {
                     PyBytesWriter_Discard(writer);
-                    return std::ptr::null_mut();
+                    return core::ptr::null_mut();
             }
-            std::mem::replace(&mut (*writer).obj, std::ptr::null_mut())
+            core::mem::replace(&mut (*writer).obj, core::ptr::null_mut())
         };
 
         PyBytesWriter_Discard(writer);
@@ -90,7 +90,7 @@ compat_function!(
     originally_defined_for(all(Py_3_15, not(Py_LIMITED_API)));
 
     #[inline]
-    pub unsafe fn PyBytesWriter_GetData(writer: *mut PyBytesWriter) -> *mut std::ffi::c_void {
+    pub unsafe fn PyBytesWriter_GetData(writer: *mut PyBytesWriter) -> *mut core::ffi::c_void {
         if (*writer).obj.is_null() {
             (*writer).small_buffer.as_ptr() as *mut _
         } else {
@@ -114,7 +114,7 @@ compat_function!(
     originally_defined_for(all(Py_3_15, not(Py_LIMITED_API)));
 
     #[inline]
-    pub unsafe fn PyBytesWriter_Resize(writer: *mut PyBytesWriter, size: crate::Py_ssize_t) -> std::ffi::c_int {
+    pub unsafe fn PyBytesWriter_Resize(writer: *mut PyBytesWriter, size: crate::Py_ssize_t) -> core::ffi::c_int {
         if size < 0 {
             crate::PyErr_SetString(crate::PyExc_ValueError, c"size must be >= 0".as_ptr());
             return -1;
@@ -130,7 +130,7 @@ compat_function!(
 #[repr(C)]
 #[cfg(not(any(Py_3_15, Py_LIMITED_API)))]
 pub struct PyBytesWriter {
-    small_buffer: [std::ffi::c_char; 256],
+    small_buffer: [core::ffi::c_char; 256],
     obj: *mut crate::PyObject,
     size: crate::Py_ssize_t,
 }
@@ -140,13 +140,13 @@ pub struct PyBytesWriter {
 unsafe fn _PyBytesWriter_Resize_impl(
     writer: *mut PyBytesWriter,
     mut size: crate::Py_ssize_t,
-    resize: std::ffi::c_int,
-) -> std::ffi::c_int {
+    resize: core::ffi::c_int,
+) -> core::ffi::c_int {
     let overallocate = resize;
     assert!(size >= 0);
 
     let allocated = if (*writer).obj.is_null() {
-        std::mem::size_of_val(&(*writer).small_buffer) as _
+        core::mem::size_of_val(&(*writer).small_buffer) as _
     } else {
         crate::PyBytes_Size((*writer).obj)
     };
@@ -173,18 +173,18 @@ unsafe fn _PyBytesWriter_Resize_impl(
         }
         assert!(!(*writer).obj.is_null())
     } else {
-        (*writer).obj = crate::PyBytes_FromStringAndSize(std::ptr::null_mut(), size);
+        (*writer).obj = crate::PyBytes_FromStringAndSize(core::ptr::null_mut(), size);
         if (*writer).obj.is_null() {
             return -1;
         }
 
         if resize > 0 {
-            assert!((size as usize) > std::mem::size_of_val(&(*writer).small_buffer));
+            assert!((size as usize) > core::mem::size_of_val(&(*writer).small_buffer));
 
-            std::ptr::copy_nonoverlapping(
+            core::ptr::copy_nonoverlapping(
                 (*writer).small_buffer.as_ptr(),
                 crate::PyBytes_AS_STRING((*writer).obj) as *mut _,
-                std::mem::size_of_val(&(*writer).small_buffer),
+                core::mem::size_of_val(&(*writer).small_buffer),
             );
         }
     }
diff --git a/pyo3-ffi/src/compat/py_3_9.rs b/pyo3-ffi/src/compat/py_3_9.rs
index 6b3521cc167..fed7e21aaa5 100644
--- a/pyo3-ffi/src/compat/py_3_9.rs
+++ b/pyo3-ffi/src/compat/py_3_9.rs
@@ -6,7 +6,7 @@ compat_function!(
 
     #[inline]
     pub unsafe fn PyObject_CallNoArgs(obj: *mut crate::PyObject) -> *mut crate::PyObject {
-        crate::PyObject_CallObject(obj, std::ptr::null_mut())
+        crate::PyObject_CallObject(obj, core::ptr::null_mut())
     }
 );
 
@@ -15,6 +15,6 @@ compat_function!(
 
     #[inline]
     pub unsafe fn PyObject_CallMethodNoArgs(obj: *mut crate::PyObject, name: *mut crate::PyObject) -> *mut crate::PyObject {
-        crate::PyObject_CallMethodObjArgs(obj, name, std::ptr::null_mut::<crate::PyObject>())
+        crate::PyObject_CallMethodObjArgs(obj, name, core::ptr::null_mut::<crate::PyObject>())
     }
 );
diff --git a/pyo3-ffi/src/compile.rs b/pyo3-ffi/src/compile.rs
index 988d5b26b0f..6e5f67fb395 100644
--- a/pyo3-ffi/src/compile.rs
+++ b/pyo3-ffi/src/compile.rs
@@ -1,4 +1,4 @@
-use std::ffi::c_int;
+use core::ffi::c_int;
 
 pub const Py_single_input: c_int = 256;
 pub const Py_file_input: c_int = 257;
diff --git a/pyo3-ffi/src/complexobject.rs b/pyo3-ffi/src/complexobject.rs
index 1e960c5cdb1..7e4b08ac075 100644
--- a/pyo3-ffi/src/complexobject.rs
+++ b/pyo3-ffi/src/complexobject.rs
@@ -1,5 +1,5 @@
 use crate::object::*;
-use std::ffi::{c_double, c_int};
+use core::ffi::{c_double, c_int};
 
 #[cfg(not(RustPython))]
 extern_libpython! {
diff --git a/pyo3-ffi/src/context.rs b/pyo3-ffi/src/context.rs
index 6eb8bf4f33b..5defd44dbfa 100644
--- a/pyo3-ffi/src/context.rs
+++ b/pyo3-ffi/src/context.rs
@@ -3,7 +3,7 @@ use crate::object::PyObject;
 use crate::object::PyTypeObject;
 #[cfg(not(RustPython))]
 use crate::Py_IS_TYPE;
-use std::ffi::{c_char, c_int};
+use core::ffi::{c_char, c_int};
 
 #[cfg(not(RustPython))]
 extern_libpython! {
diff --git a/pyo3-ffi/src/cpython/abstract_.rs b/pyo3-ffi/src/cpython/abstract_.rs
index aea3740ed3c..eb8f0467048 100644
--- a/pyo3-ffi/src/cpython/abstract_.rs
+++ b/pyo3-ffi/src/cpython/abstract_.rs
@@ -1,8 +1,8 @@
 use crate::{vectorcallfunc, PyObject, Py_TYPE, Py_ssize_t};
 #[cfg(all(any(not(PyPy), not(Py_3_11)), not(Py_3_12)))]
-use std::ffi::c_char;
+use core::ffi::c_char;
 #[cfg(not(Py_3_11))]
-use std::ffi::c_int;
+use core::ffi::c_int;
 
 #[cfg(not(any(PyPy, GraalPy)))]
 use crate::{
@@ -44,7 +44,7 @@ extern_libpython! {
 
 #[cfg(not(Py_3_12))]
 const PY_VECTORCALL_ARGUMENTS_OFFSET: size_t = (1 as size_t)
-    .checked_shl((8 * std::mem::size_of::<size_t>() - 1) as u32)
+    .checked_shl((8 * core::mem::size_of::<size_t>() - 1) as u32)
     .expect("size_t should fit the flag bits");
 
 #[cfg(Py_3_12)] // public API from 3.12
@@ -97,7 +97,7 @@ unsafe fn _PyObject_VectorcallTstate(
         }
         Some(func) => {
             let res = func(callable, args, nargsf, kwnames);
-            _Py_CheckFunctionResult(tstate, callable, res, std::ptr::null_mut())
+            _Py_CheckFunctionResult(tstate, callable, res, core::ptr::null_mut())
         }
     }
 }
@@ -132,11 +132,11 @@ extern_libpython! {
 #[inline(always)]
 pub unsafe fn PyObject_CallOneArg(func: *mut PyObject, arg: *mut PyObject) -> *mut PyObject {
     assert!(!arg.is_null());
-    let args_array = [std::ptr::null_mut(), arg];
+    let args_array = [core::ptr::null_mut(), arg];
     let args = args_array.as_ptr().offset(1); // For PY_VECTORCALL_ARGUMENTS_OFFSET
     let tstate = PyThreadState_GET();
     let nargsf = 1 | PY_VECTORCALL_ARGUMENTS_OFFSET;
-    _PyObject_VectorcallTstate(tstate, func, args, nargsf, std::ptr::null_mut())
+    _PyObject_VectorcallTstate(tstate, func, args, nargsf, core::ptr::null_mut())
 }
 
 extern_libpython! {
@@ -155,7 +155,7 @@ pub unsafe fn PyObject_CallMethodNoArgs(
         name,
         &self_,
         1 | PY_VECTORCALL_ARGUMENTS_OFFSET,
-        std::ptr::null_mut(),
+        core::ptr::null_mut(),
     )
 }
 
@@ -172,7 +172,7 @@ pub unsafe fn PyObject_CallMethodOneArg(
         name,
         args.as_ptr(),
         2 | PY_VECTORCALL_ARGUMENTS_OFFSET,
-        std::ptr::null_mut(),
+        core::ptr::null_mut(),
     )
 }
 
@@ -200,12 +200,12 @@ extern_libpython! {
     pub fn PyBuffer_GetPointer(
         view: *mut Py_buffer,
         indices: *mut Py_ssize_t,
-    ) -> *mut std::ffi::c_void;
+    ) -> *mut core::ffi::c_void;
     #[cfg_attr(PyPy, link_name = "PyPyBuffer_SizeFromFormat")]
     pub fn PyBuffer_SizeFromFormat(format: *const c_char) -> Py_ssize_t;
     #[cfg_attr(PyPy, link_name = "PyPyBuffer_ToContiguous")]
     pub fn PyBuffer_ToContiguous(
-        buf: *mut std::ffi::c_void,
+        buf: *mut core::ffi::c_void,
         view: *mut Py_buffer,
         len: Py_ssize_t,
         order: c_char,
@@ -213,7 +213,7 @@ extern_libpython! {
     #[cfg_attr(PyPy, link_name = "PyPyBuffer_FromContiguous")]
     pub fn PyBuffer_FromContiguous(
         view: *mut Py_buffer,
-        buf: *mut std::ffi::c_void,
+        buf: *mut core::ffi::c_void,
         len: Py_ssize_t,
         order: c_char,
     ) -> c_int;
@@ -231,7 +231,7 @@ extern_libpython! {
     pub fn PyBuffer_FillInfo(
         view: *mut Py_buffer,
         o: *mut PyObject,
-        buf: *mut std::ffi::c_void,
+        buf: *mut core::ffi::c_void,
         len: Py_ssize_t,
         readonly: c_int,
         flags: c_int,
diff --git a/pyo3-ffi/src/cpython/bytearrayobject.rs b/pyo3-ffi/src/cpython/bytearrayobject.rs
index a39158bace4..8a922fcb6b5 100644
--- a/pyo3-ffi/src/cpython/bytearrayobject.rs
+++ b/pyo3-ffi/src/cpython/bytearrayobject.rs
@@ -1,9 +1,9 @@
 use crate::object::*;
 use crate::pyport::Py_ssize_t;
 #[cfg(not(any(PyPy, GraalPy)))]
-use std::ffi::c_char;
+use core::ffi::c_char;
 #[cfg(not(Py_3_9))]
-use std::ffi::c_int;
+use core::ffi::c_int;
 
 #[cfg(not(any(PyPy, GraalPy, Py_LIMITED_API)))]
 #[repr(C)]
diff --git a/pyo3-ffi/src/cpython/bytesobject.rs b/pyo3-ffi/src/cpython/bytesobject.rs
index 3cdb46b956b..72e9cfb12f4 100644
--- a/pyo3-ffi/src/cpython/bytesobject.rs
+++ b/pyo3-ffi/src/cpython/bytesobject.rs
@@ -1,10 +1,10 @@
 use crate::object::*;
 use crate::Py_ssize_t;
 #[cfg(not(Py_LIMITED_API))]
-use std::ffi::c_char;
-use std::ffi::c_int;
+use core::ffi::c_char;
+use core::ffi::c_int;
 #[cfg(Py_3_15)]
-use std::ffi::c_void;
+use core::ffi::c_void;
 
 #[cfg(not(any(PyPy, GraalPy, Py_LIMITED_API)))]
 #[repr(C)]
diff --git a/pyo3-ffi/src/cpython/cellobject.rs b/pyo3-ffi/src/cpython/cellobject.rs
index 474d253aa38..faa6429fe12 100644
--- a/pyo3-ffi/src/cpython/cellobject.rs
+++ b/pyo3-ffi/src/cpython/cellobject.rs
@@ -1,5 +1,5 @@
 use crate::object::*;
-use std::ffi::c_int;
+use core::ffi::c_int;
 
 #[cfg(not(any(PyPy, GraalPy)))]
 #[repr(C)]
diff --git a/pyo3-ffi/src/cpython/ceval.rs b/pyo3-ffi/src/cpython/ceval.rs
index 50c5a74480d..682280b6c15 100644
--- a/pyo3-ffi/src/cpython/ceval.rs
+++ b/pyo3-ffi/src/cpython/ceval.rs
@@ -1,6 +1,6 @@
 use crate::cpython::pystate::Py_tracefunc;
 use crate::object::{freefunc, PyObject};
-use std::ffi::c_int;
+use core::ffi::c_int;
 
 extern_libpython! {
     // skipped non-limited _PyEval_CallTracing
diff --git a/pyo3-ffi/src/cpython/code.rs b/pyo3-ffi/src/cpython/code.rs
index acbfb5c817a..9744256002a 100644
--- a/pyo3-ffi/src/cpython/code.rs
+++ b/pyo3-ffi/src/cpython/code.rs
@@ -4,8 +4,8 @@ use crate::pyport::Py_ssize_t;
 #[cfg(not(GraalPy))]
 use crate::PyCodeObject;
 #[cfg(not(GraalPy))]
-use std::ffi::c_char;
-use std::ffi::{c_int, c_void};
+use core::ffi::c_char;
+use core::ffi::{c_int, c_void};
 
 // skipped private _PY_MONITORING_LOCAL_EVENTS
 // skipped private _PY_MONITORING_UNGROUPED_EVENTS
diff --git a/pyo3-ffi/src/cpython/compile.rs b/pyo3-ffi/src/cpython/compile.rs
index 90df57052d0..c6e8b2554d9 100644
--- a/pyo3-ffi/src/cpython/compile.rs
+++ b/pyo3-ffi/src/cpython/compile.rs
@@ -8,8 +8,8 @@ use crate::pythonrun::*;
 use crate::PyCodeObject;
 use crate::INT_MAX;
 #[cfg(not(any(PyPy, Py_3_10)))]
-use std::ffi::c_char;
-use std::ffi::c_int;
+use core::ffi::c_char;
+use core::ffi::c_int;
 
 // skipped PyCF_MASK
 // skipped PyCF_MASK_OBSOLETE
diff --git a/pyo3-ffi/src/cpython/complexobject.rs b/pyo3-ffi/src/cpython/complexobject.rs
index d5881feaa7d..d3d29ce0d80 100644
--- a/pyo3-ffi/src/cpython/complexobject.rs
+++ b/pyo3-ffi/src/cpython/complexobject.rs
@@ -1,5 +1,5 @@
 use crate::PyObject;
-use std::ffi::c_double;
+use core::ffi::c_double;
 
 #[repr(C)]
 #[derive(Copy, Clone)]
diff --git a/pyo3-ffi/src/cpython/descrobject.rs b/pyo3-ffi/src/cpython/descrobject.rs
index 9d26b870022..e2e40efb7eb 100644
--- a/pyo3-ffi/src/cpython/descrobject.rs
+++ b/pyo3-ffi/src/cpython/descrobject.rs
@@ -1,5 +1,5 @@
 use crate::{PyGetSetDef, PyMethodDef, PyObject, PyTypeObject};
-use std::ffi::{c_char, c_int, c_void};
+use core::ffi::{c_char, c_int, c_void};
 
 #[cfg(Py_3_11)]
 use crate::PyMemberDef;
diff --git a/pyo3-ffi/src/cpython/dictobject.rs b/pyo3-ffi/src/cpython/dictobject.rs
index cf5be14f3ee..1bd75d8c6c5 100644
--- a/pyo3-ffi/src/cpython/dictobject.rs
+++ b/pyo3-ffi/src/cpython/dictobject.rs
@@ -4,9 +4,9 @@ use crate::object::*;
 use crate::pyport::Py_ssize_t;
 
 #[cfg(all(not(PyPy), Py_3_13))]
-use std::ffi::c_char;
+use core::ffi::c_char;
 #[cfg(all(not(PyPy), Py_3_12))]
-use std::ffi::c_int;
+use core::ffi::c_int;
 
 #[cfg(not(PyPy))]
 opaque_struct!(pub PyDictKeysObject);
diff --git a/pyo3-ffi/src/cpython/floatobject.rs b/pyo3-ffi/src/cpython/floatobject.rs
index 4b9ef1a2484..e3ff9a3371f 100644
--- a/pyo3-ffi/src/cpython/floatobject.rs
+++ b/pyo3-ffi/src/cpython/floatobject.rs
@@ -1,7 +1,7 @@
 #[cfg(GraalPy)]
 use crate::PyFloat_AsDouble;
 use crate::{PyFloat_Check, PyObject};
-use std::ffi::c_double;
+use core::ffi::c_double;
 
 #[repr(C)]
 pub struct PyFloatObject {
diff --git a/pyo3-ffi/src/cpython/frameobject.rs b/pyo3-ffi/src/cpython/frameobject.rs
index f1370523a95..c79d688577d 100644
--- a/pyo3-ffi/src/cpython/frameobject.rs
+++ b/pyo3-ffi/src/cpython/frameobject.rs
@@ -6,8 +6,8 @@ use crate::PyFrameObject;
 #[cfg(not(GraalPy))]
 use crate::PyThreadState;
 #[cfg(not(any(PyPy, GraalPy, Py_3_11)))]
-use std::ffi::c_char;
-use std::ffi::c_int;
+use core::ffi::c_char;
+use core::ffi::c_int;
 
 #[cfg(not(any(PyPy, GraalPy, Py_3_11)))]
 pub type PyFrameState = c_char;
diff --git a/pyo3-ffi/src/cpython/funcobject.rs b/pyo3-ffi/src/cpython/funcobject.rs
index 57a679e5704..b1e4c052a15 100644
--- a/pyo3-ffi/src/cpython/funcobject.rs
+++ b/pyo3-ffi/src/cpython/funcobject.rs
@@ -1,5 +1,5 @@
 use crate::{PyObject, Py_IS_TYPE};
-use std::ffi::c_int;
+use core::ffi::c_int;
 
 #[cfg(all(not(any(PyPy, GraalPy)), not(Py_3_10)))]
 #[repr(C)]
diff --git a/pyo3-ffi/src/cpython/genobject.rs b/pyo3-ffi/src/cpython/genobject.rs
index 52b8e4b4f24..c97de71ff77 100644
--- a/pyo3-ffi/src/cpython/genobject.rs
+++ b/pyo3-ffi/src/cpython/genobject.rs
@@ -1,8 +1,8 @@
 use crate::object::*;
 use crate::PyFrameObject;
 #[cfg(all(Py_3_11, not(any(PyPy, GraalPy, Py_3_14))))]
-use std::ffi::c_char;
-use std::ffi::c_int;
+use core::ffi::c_char;
+use core::ffi::c_int;
 
 #[cfg(not(any(PyPy, GraalPy, Py_3_14)))]
 #[repr(C)]
diff --git a/pyo3-ffi/src/cpython/import.rs b/pyo3-ffi/src/cpython/import.rs
index 4655aa0e5af..4b358f01489 100644
--- a/pyo3-ffi/src/cpython/import.rs
+++ b/pyo3-ffi/src/cpython/import.rs
@@ -1,9 +1,9 @@
 #[cfg(any(not(PyPy), Py_3_14))]
 use crate::PyObject;
 #[cfg(any(not(PyPy), Py_3_14))]
-use std::ffi::c_char;
+use core::ffi::c_char;
 #[cfg(not(PyPy))]
-use std::ffi::{c_int, c_uchar};
+use core::ffi::{c_int, c_uchar};
 
 #[cfg(not(PyPy))]
 #[repr(C)]
diff --git a/pyo3-ffi/src/cpython/initconfig.rs b/pyo3-ffi/src/cpython/initconfig.rs
index 081774d615a..4d3696ae442 100644
--- a/pyo3-ffi/src/cpython/initconfig.rs
+++ b/pyo3-ffi/src/cpython/initconfig.rs
@@ -1,8 +1,8 @@
 /* --- PyStatus ----------------------------------------------- */
 
 use crate::Py_ssize_t;
+use core::ffi::{c_char, c_int, c_ulong};
 use libc::wchar_t;
-use std::ffi::{c_char, c_int, c_ulong};
 
 #[repr(C)]
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
diff --git a/pyo3-ffi/src/cpython/lock.rs b/pyo3-ffi/src/cpython/lock.rs
index 2565e40534f..f97b049d8e4 100644
--- a/pyo3-ffi/src/cpython/lock.rs
+++ b/pyo3-ffi/src/cpython/lock.rs
@@ -1,6 +1,6 @@
 #[cfg(Py_3_14)]
-use std::ffi::c_int;
-use std::sync::atomic::AtomicU8;
+use core::ffi::c_int;
+use core::sync::atomic::AtomicU8;
 
 #[repr(transparent)]
 #[derive(Debug)]
diff --git a/pyo3-ffi/src/cpython/longobject.rs b/pyo3-ffi/src/cpython/longobject.rs
index 92bb4c6150d..ef0e2c465b1 100644
--- a/pyo3-ffi/src/cpython/longobject.rs
+++ b/pyo3-ffi/src/cpython/longobject.rs
@@ -2,10 +2,10 @@ use crate::longobject::*;
 use crate::object::*;
 #[cfg(Py_3_13)]
 use crate::pyport::Py_ssize_t;
-use libc::size_t;
 #[cfg(Py_3_13)]
-use std::ffi::c_void;
-use std::ffi::{c_int, c_uchar};
+use core::ffi::c_void;
+use core::ffi::{c_int, c_uchar};
+use libc::size_t;
 
 #[cfg(Py_3_13)]
 extern_libpython! {
diff --git a/pyo3-ffi/src/cpython/marshal.rs b/pyo3-ffi/src/cpython/marshal.rs
index 089992c3fc6..bd09e37baf2 100644
--- a/pyo3-ffi/src/cpython/marshal.rs
+++ b/pyo3-ffi/src/cpython/marshal.rs
@@ -1,6 +1,6 @@
 use crate::{PyObject, Py_ssize_t};
+use core::ffi::{c_char, c_int, c_long};
 use libc::FILE;
-use std::ffi::{c_char, c_int, c_long};
 
 #[cfg(Py_3_15)]
 pub const Py_MARSHAL_VERSION: c_int = 6;
diff --git a/pyo3-ffi/src/cpython/methodobject.rs b/pyo3-ffi/src/cpython/methodobject.rs
index 582d3766c33..440701ab942 100644
--- a/pyo3-ffi/src/cpython/methodobject.rs
+++ b/pyo3-ffi/src/cpython/methodobject.rs
@@ -1,7 +1,7 @@
 use crate::object::*;
 #[cfg(not(GraalPy))]
 use crate::{PyCFunctionObject, PyMethodDefPointer, METH_METHOD, METH_STATIC};
-use std::ffi::c_int;
+use core::ffi::c_int;
 
 #[cfg(not(GraalPy))]
 pub struct PyCMethodObject {
@@ -39,7 +39,7 @@ pub unsafe fn PyCFunction_GET_SELF(func: *mut PyObject) -> *mut PyObject {
 
     let func = func.cast::<PyCFunctionObject>();
     if (*(*func).m_ml).ml_flags & METH_STATIC != 0 {
-        std::ptr::null_mut()
+        core::ptr::null_mut()
     } else {
         (*func).m_self
     }
@@ -64,6 +64,6 @@ pub unsafe fn PyCFunction_GET_CLASS(func: *mut PyObject) -> *mut PyTypeObject {
         let func = func.cast::<PyCMethodObject>();
         (*func).mm_class
     } else {
-        std::ptr::null_mut()
+        core::ptr::null_mut()
     }
 }
diff --git a/pyo3-ffi/src/cpython/object.rs b/pyo3-ffi/src/cpython/object.rs
index 1aff7835a57..8a7ce069cc8 100644
--- a/pyo3-ffi/src/cpython/object.rs
+++ b/pyo3-ffi/src/cpython/object.rs
@@ -1,7 +1,7 @@
 use crate::vectorcallfunc;
 use crate::{object, PyGetSetDef, PyMemberDef, PyMethodDef, PyObject, Py_ssize_t};
-use std::ffi::{c_char, c_int, c_uint, c_void};
-use std::mem;
+use core::ffi::{c_char, c_int, c_uint, c_void};
+use core::mem;
 
 // skipped private _Py_NewReference
 // skipped private _Py_NewReferenceNoTotal
@@ -22,8 +22,8 @@ use std::mem;
 #[cfg(not(Py_3_11))] // moved to src/buffer.rs from Python
 mod bufferinfo {
     use crate::Py_ssize_t;
-    use std::ffi::{c_char, c_int, c_void};
-    use std::ptr;
+    use core::ffi::{c_char, c_int, c_void};
+    use core::ptr;
 
     #[repr(C)]
     #[derive(Copy, Clone)]
@@ -230,7 +230,7 @@ pub struct PyTypeObject {
     pub tp_setattro: Option<object::setattrofunc>,
     pub tp_as_buffer: *mut PyBufferProcs,
     #[cfg(not(Py_GIL_DISABLED))]
-    pub tp_flags: std::ffi::c_ulong,
+    pub tp_flags: core::ffi::c_ulong,
     #[cfg(Py_GIL_DISABLED)]
     pub tp_flags: crate::impl_::AtomicCULong,
     pub tp_doc: *const c_char,
diff --git a/pyo3-ffi/src/cpython/objimpl.rs b/pyo3-ffi/src/cpython/objimpl.rs
index 38d18221b41..b2810bc1660 100644
--- a/pyo3-ffi/src/cpython/objimpl.rs
+++ b/pyo3-ffi/src/cpython/objimpl.rs
@@ -1,9 +1,9 @@
+use core::ffi::c_int;
 #[cfg(not(all(Py_3_11, any(PyPy, GraalPy))))]
 use libc::size_t;
-use std::ffi::c_int;
 
 #[cfg(not(any(PyPy, GraalPy)))]
-use std::ffi::c_void;
+use core::ffi::c_void;
 
 use crate::object::*;
 
@@ -28,7 +28,7 @@ pub struct PyObjectArenaAllocator {
 impl Default for PyObjectArenaAllocator {
     #[inline]
     fn default() -> Self {
-        unsafe { std::mem::zeroed() }
+        unsafe { core::mem::zeroed() }
     }
 }
 
diff --git a/pyo3-ffi/src/cpython/pydebug.rs b/pyo3-ffi/src/cpython/pydebug.rs
index 3e50bf0cff5..389c4ea9ef3 100644
--- a/pyo3-ffi/src/cpython/pydebug.rs
+++ b/pyo3-ffi/src/cpython/pydebug.rs
@@ -1,4 +1,4 @@
-use std::ffi::{c_char, c_int};
+use core::ffi::{c_char, c_int};
 
 #[cfg(not(Py_LIMITED_API))]
 extern_libpython! {
@@ -64,7 +64,7 @@ extern_libpython! {
 pub unsafe fn Py_GETENV(name: *const c_char) -> *mut c_char {
     #[allow(deprecated)]
     if Py_IgnoreEnvironmentFlag != 0 {
-        std::ptr::null_mut()
+        core::ptr::null_mut()
     } else {
         libc::getenv(name)
     }
diff --git a/pyo3-ffi/src/cpython/pyframe.rs b/pyo3-ffi/src/cpython/pyframe.rs
index 718eed46d65..b672ad103b9 100644
--- a/pyo3-ffi/src/cpython/pyframe.rs
+++ b/pyo3-ffi/src/cpython/pyframe.rs
@@ -2,8 +2,8 @@
 use crate::PyFrameObject;
 use crate::{PyObject, PyTypeObject, Py_IS_TYPE};
 #[cfg(Py_3_12)]
-use std::ffi::c_char;
-use std::ffi::c_int;
+use core::ffi::c_char;
+use core::ffi::c_int;
 
 // NB used in `_PyEval_EvalFrameDefault`, maybe we remove this too.
 #[cfg(all(Py_3_11, not(PyPy)))]
diff --git a/pyo3-ffi/src/cpython/pyhash.rs b/pyo3-ffi/src/cpython/pyhash.rs
index 057725a205b..6ec53f86587 100644
--- a/pyo3-ffi/src/cpython/pyhash.rs
+++ b/pyo3-ffi/src/cpython/pyhash.rs
@@ -3,9 +3,9 @@ use crate::Py_ssize_t;
 #[cfg(Py_3_13)]
 use crate::{PyObject, Py_hash_t};
 #[cfg(any(Py_3_13, not(PyPy)))]
-use std::ffi::c_void;
+use core::ffi::c_void;
 #[cfg(not(PyPy))]
-use std::ffi::{c_char, c_int};
+use core::ffi::{c_char, c_int};
 
 #[cfg(not(PyPy))]
 #[repr(C)]
@@ -22,7 +22,7 @@ pub struct PyHash_FuncDef {
 impl Default for PyHash_FuncDef {
     #[inline]
     fn default() -> Self {
-        unsafe { std::mem::zeroed() }
+        unsafe { core::mem::zeroed() }
     }
 }
 
diff --git a/pyo3-ffi/src/cpython/pylifecycle.rs b/pyo3-ffi/src/cpython/pylifecycle.rs
index a6828778062..07240d8c28e 100644
--- a/pyo3-ffi/src/cpython/pylifecycle.rs
+++ b/pyo3-ffi/src/cpython/pylifecycle.rs
@@ -1,6 +1,6 @@
 use crate::{PyConfig, PyPreConfig, PyStatus, Py_ssize_t};
+use core::ffi::{c_char, c_int};
 use libc::wchar_t;
-use std::ffi::{c_char, c_int};
 
 extern_libpython! {
 
diff --git a/pyo3-ffi/src/cpython/pymem.rs b/pyo3-ffi/src/cpython/pymem.rs
index 6c0c973842e..808e4a5b5d0 100644
--- a/pyo3-ffi/src/cpython/pymem.rs
+++ b/pyo3-ffi/src/cpython/pymem.rs
@@ -1,5 +1,5 @@
+use core::ffi::c_void;
 use libc::size_t;
-use std::ffi::c_void;
 
 extern_libpython! {
     #[cfg_attr(PyPy, link_name = "PyPyMem_RawMalloc")]
diff --git a/pyo3-ffi/src/cpython/pystate.rs b/pyo3-ffi/src/cpython/pystate.rs
index 4f8bd7b3786..52e15224cc2 100644
--- a/pyo3-ffi/src/cpython/pystate.rs
+++ b/pyo3-ffi/src/cpython/pystate.rs
@@ -1,6 +1,6 @@
 use crate::PyThreadState;
 use crate::{PyFrameObject, PyInterpreterState, PyObject};
-use std::ffi::c_int;
+use core::ffi::c_int;
 
 // skipped private _PyInterpreterState_RequiresIDRef
 // skipped private _PyInterpreterState_RequireIDRef
diff --git a/pyo3-ffi/src/cpython/pythonrun.rs b/pyo3-ffi/src/cpython/pythonrun.rs
index d3a3c9c03ce..697747d05fa 100644
--- a/pyo3-ffi/src/cpython/pythonrun.rs
+++ b/pyo3-ffi/src/cpython/pythonrun.rs
@@ -4,8 +4,8 @@ use crate::pyarena::PyArena;
 use crate::PyCompilerFlags;
 #[cfg(not(any(PyPy, GraalPy, Py_3_10)))]
 use crate::{_mod, _node};
+use core::ffi::{c_char, c_int};
 use libc::FILE;
-use std::ffi::{c_char, c_int};
 
 extern_libpython! {
     pub fn PyRun_SimpleStringFlags(arg1: *const c_char, arg2: *mut PyCompilerFlags) -> c_int;
@@ -137,7 +137,7 @@ extern_libpython! {
 #[inline]
 #[cfg(not(any(PyPy, GraalPy)))]
 pub unsafe fn Py_CompileString(string: *const c_char, p: *const c_char, s: c_int) -> *mut PyObject {
-    Py_CompileStringExFlags(string, p, s, std::ptr::null_mut(), -1)
+    Py_CompileStringExFlags(string, p, s, core::ptr::null_mut(), -1)
 }
 
 #[inline]
diff --git a/pyo3-ffi/src/cpython/traceback.rs b/pyo3-ffi/src/cpython/traceback.rs
index 43c7a66b5aa..6542633db28 100644
--- a/pyo3-ffi/src/cpython/traceback.rs
+++ b/pyo3-ffi/src/cpython/traceback.rs
@@ -1,6 +1,6 @@
 use crate::object::PyObject;
 use crate::PyFrameObject;
-use std::ffi::c_int;
+use core::ffi::c_int;
 
 #[repr(C)]
 pub struct PyTracebackObject {
diff --git a/pyo3-ffi/src/cpython/unicodeobject.rs b/pyo3-ffi/src/cpython/unicodeobject.rs
index d6747317a31..9117d4d90e8 100644
--- a/pyo3-ffi/src/cpython/unicodeobject.rs
+++ b/pyo3-ffi/src/cpython/unicodeobject.rs
@@ -1,8 +1,8 @@
 #[cfg(any(Py_3_11, not(PyPy)))]
 use crate::Py_hash_t;
 use crate::{PyObject, Py_UCS1, Py_UCS2, Py_UCS4, Py_ssize_t};
+use core::ffi::{c_char, c_int, c_uint, c_void};
 use libc::wchar_t;
-use std::ffi::{c_char, c_int, c_uint, c_void};
 
 // skipped Py_UNICODE_ISSPACE()
 // skipped Py_UNICODE_ISLOWER()
@@ -174,7 +174,7 @@ struct PyASCIIObjectState {
 impl PyASCIIObjectState {
     #[inline]
     unsafe fn interned(&self) -> c_uint {
-        std::mem::transmute(
+        core::mem::transmute(
             self.bitfield
                 .get(STATE_INTERNED_INDEX, STATE_INTERNED_WIDTH) as u32,
         )
@@ -182,43 +182,43 @@ impl PyASCIIObjectState {
 
     #[inline]
     unsafe fn set_interned(&mut self, val: c_uint) {
-        let val: u32 = std::mem::transmute(val);
+        let val: u32 = core::mem::transmute(val);
         self.bitfield
             .set(STATE_INTERNED_INDEX, STATE_INTERNED_WIDTH, val as u64)
     }
 
     #[inline]
     unsafe fn kind(&self) -> c_uint {
-        std::mem::transmute(self.bitfield.get(STATE_KIND_INDEX, STATE_KIND_WIDTH) as u32)
+        core::mem::transmute(self.bitfield.get(STATE_KIND_INDEX, STATE_KIND_WIDTH) as u32)
     }
 
     #[inline]
     unsafe fn set_kind(&mut self, val: c_uint) {
-        let val: u32 = std::mem::transmute(val);
+        let val: u32 = core::mem::transmute(val);
         self.bitfield
             .set(STATE_KIND_INDEX, STATE_KIND_WIDTH, val as u64)
     }
 
     #[inline]
     unsafe fn compact(&self) -> c_uint {
-        std::mem::transmute(self.bitfield.get(STATE_COMPACT_INDEX, STATE_COMPACT_WIDTH) as u32)
+        core::mem::transmute(self.bitfield.get(STATE_COMPACT_INDEX, STATE_COMPACT_WIDTH) as u32)
     }
 
     #[inline]
     unsafe fn set_compact(&mut self, val: c_uint) {
-        let val: u32 = std::mem::transmute(val);
+        let val: u32 = core::mem::transmute(val);
         self.bitfield
             .set(STATE_COMPACT_INDEX, STATE_COMPACT_WIDTH, val as u64)
     }
 
     #[inline]
     unsafe fn ascii(&self) -> c_uint {
-        std::mem::transmute(self.bitfield.get(STATE_ASCII_INDEX, STATE_ASCII_WIDTH) as u32)
+        core::mem::transmute(self.bitfield.get(STATE_ASCII_INDEX, STATE_ASCII_WIDTH) as u32)
     }
 
     #[inline]
     unsafe fn set_ascii(&mut self, val: c_uint) {
-        let val: u32 = std::mem::transmute(val);
+        let val: u32 = core::mem::transmute(val);
         self.bitfield
             .set(STATE_ASCII_INDEX, STATE_ASCII_WIDTH, val as u64)
     }
@@ -226,7 +226,7 @@ impl PyASCIIObjectState {
     #[cfg(Py_3_12)]
     #[inline]
     unsafe fn statically_allocated(&self) -> c_uint {
-        std::mem::transmute(self.bitfield.get(
+        core::mem::transmute(self.bitfield.get(
             STATE_STATICALLY_ALLOCATED_INDEX,
             STATE_STATICALLY_ALLOCATED_WIDTH,
         ) as u32)
@@ -235,7 +235,7 @@ impl PyASCIIObjectState {
     #[cfg(Py_3_12)]
     #[inline]
     unsafe fn set_statically_allocated(&mut self, val: c_uint) {
-        let val: u32 = std::mem::transmute(val);
+        let val: u32 = core::mem::transmute(val);
         self.bitfield.set(
             STATE_STATICALLY_ALLOCATED_INDEX,
             STATE_STATICALLY_ALLOCATED_WIDTH,
@@ -246,13 +246,13 @@ impl PyASCIIObjectState {
     #[cfg(not(Py_3_12))]
     #[inline]
     unsafe fn ready(&self) -> c_uint {
-        std::mem::transmute(self.bitfield.get(STATE_READY_INDEX, STATE_READY_WIDTH) as u32)
+        core::mem::transmute(self.bitfield.get(STATE_READY_INDEX, STATE_READY_WIDTH) as u32)
     }
 
     #[cfg(not(Py_3_12))]
     #[inline]
     unsafe fn set_ready(&mut self, val: c_uint) {
-        let val: u32 = std::mem::transmute(val);
+        let val: u32 = core::mem::transmute(val);
         self.bitfield
             .set(STATE_READY_INDEX, STATE_READY_WIDTH, val as u64)
     }
diff --git a/pyo3-ffi/src/cpython/warnings.rs b/pyo3-ffi/src/cpython/warnings.rs
index fe6f3d3523a..f3330e69ae5 100644
--- a/pyo3-ffi/src/cpython/warnings.rs
+++ b/pyo3-ffi/src/cpython/warnings.rs
@@ -1,5 +1,5 @@
 use crate::object::PyObject;
-use std::ffi::c_int;
+use core::ffi::c_int;
 
 extern_libpython! {
     pub fn PyErr_WarnExplicitObject(
diff --git a/pyo3-ffi/src/datetime.rs b/pyo3-ffi/src/datetime.rs
index e967541335e..7ed4e8af9c5 100644
--- a/pyo3-ffi/src/datetime.rs
+++ b/pyo3-ffi/src/datetime.rs
@@ -9,13 +9,13 @@ use crate::PyCapsule_Import;
 #[cfg(GraalPy)]
 use crate::{PyLong_AsLong, PyLong_Check, PyObject_GetAttrString, Py_DecRef};
 use crate::{PyObject, PyObject_TypeCheck, PyTypeObject, Py_IS_TYPE, Py_None};
-use std::ffi::c_char;
-use std::ffi::c_int;
-use std::ffi::CStr;
-use std::ptr;
-use std::sync::atomic::{AtomicPtr, Ordering};
+use core::ffi::c_char;
+use core::ffi::c_int;
+use core::ffi::CStr;
+use core::ptr;
+use core::sync::atomic::{AtomicPtr, Ordering};
 #[cfg(not(PyPy))]
-use {crate::Py_hash_t, std::ffi::c_uchar};
+use {crate::Py_hash_t, core::ffi::c_uchar};
 // Type struct wrappers
 const _PyDateTime_DATE_DATASIZE: usize = 4;
 const _PyDateTime_TIME_DATASIZE: usize = 6;
@@ -350,7 +350,7 @@ pub unsafe fn PyDateTime_DELTA_GET_MICROSECONDS(o: *mut PyObject) -> c_int {
 // but copying them seems suboptimal
 #[inline]
 #[cfg(GraalPy)]
-pub unsafe fn _get_attr(obj: *mut PyObject, field: &std::ffi::CStr) -> c_int {
+pub unsafe fn _get_attr(obj: *mut PyObject, field: &core::ffi::CStr) -> c_int {
     let result = PyObject_GetAttrString(obj, field.as_ptr());
     Py_DecRef(result); // the original macros are borrowing
     if PyLong_Check(result) == 1 {
@@ -803,7 +803,7 @@ pub unsafe fn PyDelta_FromDSU(days: c_int, seconds: c_int, microseconds: c_int)
 }
 
 pub unsafe fn PyTimeZone_FromOffset(offset: *mut PyObject) -> *mut PyObject {
-    ((*PyDateTimeAPI()).TimeZone_FromTimeZone)(offset, std::ptr::null_mut())
+    ((*PyDateTimeAPI()).TimeZone_FromTimeZone)(offset, core::ptr::null_mut())
 }
 
 pub unsafe fn PyTimeZone_FromOffsetAndName(
@@ -816,7 +816,7 @@ pub unsafe fn PyTimeZone_FromOffsetAndName(
 #[cfg(not(PyPy))]
 pub unsafe fn PyDateTime_FromTimestamp(args: *mut PyObject) -> *mut PyObject {
     let f = (*PyDateTimeAPI()).DateTime_FromTimestamp;
-    f((*PyDateTimeAPI()).DateTimeType, args, std::ptr::null_mut())
+    f((*PyDateTimeAPI()).DateTimeType, args, core::ptr::null_mut())
 }
 
 #[cfg(not(PyPy))]
diff --git a/pyo3-ffi/src/descrobject.rs b/pyo3-ffi/src/descrobject.rs
index 91626733ca2..cd65e7b6a92 100644
--- a/pyo3-ffi/src/descrobject.rs
+++ b/pyo3-ffi/src/descrobject.rs
@@ -1,8 +1,8 @@
 use crate::methodobject::PyMethodDef;
 use crate::object::{PyObject, PyTypeObject};
 use crate::Py_ssize_t;
-use std::ffi::{c_char, c_int, c_void};
-use std::ptr;
+use core::ffi::{c_char, c_int, c_void};
+use core::ptr;
 
 pub type getter = unsafe extern "C" fn(slf: *mut PyObject, closure: *mut c_void) -> *mut PyObject;
 pub type setter =
diff --git a/pyo3-ffi/src/dictobject.rs b/pyo3-ffi/src/dictobject.rs
index cf587fb97a3..fec8f459e75 100644
--- a/pyo3-ffi/src/dictobject.rs
+++ b/pyo3-ffi/src/dictobject.rs
@@ -1,6 +1,6 @@
 use crate::object::*;
 use crate::pyport::Py_ssize_t;
-use std::ffi::{c_char, c_int};
+use core::ffi::{c_char, c_int};
 
 #[cfg(not(RustPython))]
 extern_libpython! {
diff --git a/pyo3-ffi/src/fileobject.rs b/pyo3-ffi/src/fileobject.rs
index be3492e9192..537e998bafa 100644
--- a/pyo3-ffi/src/fileobject.rs
+++ b/pyo3-ffi/src/fileobject.rs
@@ -1,5 +1,5 @@
 use crate::object::PyObject;
-use std::ffi::{c_char, c_int};
+use core::ffi::{c_char, c_int};
 
 pub const PY_STDIOTEXTMODE: &str = "b";
 
diff --git a/pyo3-ffi/src/fileutils.rs b/pyo3-ffi/src/fileutils.rs
index 518e2ed9fd3..c80570c6633 100644
--- a/pyo3-ffi/src/fileutils.rs
+++ b/pyo3-ffi/src/fileutils.rs
@@ -1,6 +1,6 @@
 use crate::pyport::Py_ssize_t;
+use core::ffi::c_char;
 use libc::wchar_t;
-use std::ffi::c_char;
 
 extern_libpython! {
     pub fn Py_DecodeLocale(arg1: *const c_char, size: *mut Py_ssize_t) -> *mut wchar_t;
diff --git a/pyo3-ffi/src/floatobject.rs b/pyo3-ffi/src/floatobject.rs
index fa153a384a5..5597d6d2922 100644
--- a/pyo3-ffi/src/floatobject.rs
+++ b/pyo3-ffi/src/floatobject.rs
@@ -1,5 +1,5 @@
 use crate::object::*;
-use std::ffi::{c_double, c_int};
+use core::ffi::{c_double, c_int};
 
 #[cfg(Py_LIMITED_API)]
 // TODO: remove (see https://github.com/PyO3/pyo3/pull/1341#issuecomment-751515985)
diff --git a/pyo3-ffi/src/impl_/mod.rs b/pyo3-ffi/src/impl_/mod.rs
index 064df213ba6..df759d25207 100644
--- a/pyo3-ffi/src/impl_/mod.rs
+++ b/pyo3-ffi/src/impl_/mod.rs
@@ -6,14 +6,14 @@ mod atomic_c_ulong {
         type Type;
     }
     impl AtomicCULongType for GetAtomicCULong<32> {
-        type Type = std::sync::atomic::AtomicU32;
+        type Type = core::sync::atomic::AtomicU32;
     }
     impl AtomicCULongType for GetAtomicCULong<64> {
-        type Type = std::sync::atomic::AtomicU64;
+        type Type = core::sync::atomic::AtomicU64;
     }
 
     pub type TYPE =
-        <GetAtomicCULong<{ std::mem::size_of::<std::ffi::c_ulong>() * 8 }> as AtomicCULongType>::Type;
+        <GetAtomicCULong<{ core::mem::size_of::<core::ffi::c_ulong>() * 8 }> as AtomicCULongType>::Type;
 }
 
 /// Typedef for an atomic integer to match the platform-dependent c_ulong type.
diff --git a/pyo3-ffi/src/import.rs b/pyo3-ffi/src/import.rs
index f83be787999..974083c3c25 100644
--- a/pyo3-ffi/src/import.rs
+++ b/pyo3-ffi/src/import.rs
@@ -1,5 +1,5 @@
 use crate::object::PyObject;
-use std::ffi::{c_char, c_int, c_long};
+use core::ffi::{c_char, c_int, c_long};
 
 extern_libpython! {
     pub fn PyImport_GetMagicNumber() -> c_long;
diff --git a/pyo3-ffi/src/intrcheck.rs b/pyo3-ffi/src/intrcheck.rs
index 13dacf59ae9..32702d171a8 100644
--- a/pyo3-ffi/src/intrcheck.rs
+++ b/pyo3-ffi/src/intrcheck.rs
@@ -1,4 +1,4 @@
-use std::ffi::c_int;
+use core::ffi::c_int;
 
 extern_libpython! {
     #[cfg_attr(PyPy, link_name = "PyPyOS_InterruptOccurred")]
diff --git a/pyo3-ffi/src/iterobject.rs b/pyo3-ffi/src/iterobject.rs
index ed29e4a5b40..4236a6be48f 100644
--- a/pyo3-ffi/src/iterobject.rs
+++ b/pyo3-ffi/src/iterobject.rs
@@ -1,5 +1,5 @@
 use crate::object::*;
-use std::ffi::c_int;
+use core::ffi::c_int;
 
 #[cfg(not(RustPython))]
 extern_libpython! {
diff --git a/pyo3-ffi/src/lib.rs b/pyo3-ffi/src/lib.rs
index 535d3e2c8aa..8f63e7f26ed 100644
--- a/pyo3-ffi/src/lib.rs
+++ b/pyo3-ffi/src/lib.rs
@@ -1,3 +1,4 @@
+#![no_std]
 #![cfg_attr(docsrs, feature(doc_cfg))]
 //! Raw FFI declarations for Python's C API.
 //!
@@ -127,11 +128,11 @@
 //! **`src/lib.rs`**
 //! ```rust,no_run
 //! #[cfg(Py_3_15)]
-//! use std::ffi::c_void;
+//! use core::ffi::c_void;
 //! #[cfg(not(Py_3_15))]
-//! use std::ffi::c_int;
-//! use std::ffi::{c_char, c_long};
-//! use std::ptr;
+//! use core::ffi::c_int;
+//! use core::ffi::{c_char, c_long};
+//! use core::ptr;
 //!
 //! use pyo3_ffi::*;
 //!
@@ -187,7 +188,7 @@
 //!
 //! #[cfg(Py_3_15)]
 //! static mut SLOTS: [PySlot; SLOTS_LEN] = [
-//!     PySlot_STATIC_DATA(Py_mod_abi, std::ptr::addr_of_mut!(ABI_INFO).cast()),
+//!     PySlot_STATIC_DATA(Py_mod_abi, core::ptr::addr_of_mut!(ABI_INFO).cast()),
 //!     PySlot_STATIC_DATA(Py_mod_name, c"string_sum".as_ptr() as *mut c_void),
 //!     PySlot_STATIC_DATA(Py_mod_doc, c"A Python module written in Rust.".as_ptr() as *mut c_void),
 //!     PySlot_STATIC_DATA(Py_mod_methods, (&raw mut METHODS).cast()),
@@ -250,7 +251,7 @@
 //!         let mut size = 0;
 //!         let p = PyUnicode_AsUTF8AndSize(obj_repr, &mut size);
 //!         if !p.is_null() {
-//!             let s = std::str::from_utf8_unchecked(std::slice::from_raw_parts(
+//!             let s = core::str::from_utf8_unchecked(core::slice::from_raw_parts(
 //!                 p.cast::<u8>(),
 //!                 size as usize,
 //!             ));
@@ -272,18 +273,18 @@
 //!             PyExc_TypeError,
 //!             c"sum_as_string expected 2 positional arguments".as_ptr(),
 //!         );
-//!         return std::ptr::null_mut();
+//!         return core::ptr::null_mut();
 //!     }
 //!
 //!     let (first, second) = (*args, *args.add(1));
 //!
 //!     let first = match parse_arg_as_i32(first, 1) {
 //!         Some(x) => x,
-//!         None => return std::ptr::null_mut(),
+//!         None => return core::ptr::null_mut(),
 //!     };
 //!     let second = match parse_arg_as_i32(second, 2) {
 //!         Some(x) => x,
-//!         None => return std::ptr::null_mut(),
+//!         None => return core::ptr::null_mut(),
 //!     };
 //!
 //!     match first.checked_add(second) {
@@ -293,7 +294,7 @@
 //!         }
 //!         None => {
 //!             PyErr_SetString(PyExc_OverflowError, c"arguments too large to add".as_ptr());
-//!             std::ptr::null_mut()
+//!             core::ptr::null_mut()
 //!         }
 //!     }
 //! }
@@ -364,6 +365,11 @@
     clippy::missing_safety_doc,
     clippy::ptr_eq
 )]
+#![warn(
+    clippy::alloc_instead_of_core,
+    clippy::std_instead_of_alloc,
+    clippy::std_instead_of_core
+)]
 #![warn(elided_lifetimes_in_paths, unused_lifetimes)]
 // This crate is a hand-maintained translation of CPython's headers, so requiring "unsafe"
 // blocks within those translations increases maintenance burden without providing any
@@ -371,6 +377,11 @@
 // original CPython headers
 #![allow(unsafe_op_in_unsafe_fn)]
 
+#[cfg(all(Py_3_12, py_sys_config = "Py_REF_DEBUG"))]
+extern crate alloc;
+#[cfg(not(any(Py_3_14, target_arch = "wasm32")))]
+extern crate std;
+
 // Until `extern type` is stabilized, use the recommended approach to
 // model opaque types:
 // https://doc.rust-lang.org/nomicon/ffi.html#representing-opaque-structs
@@ -393,7 +404,7 @@ macro_rules! opaque_struct {
 /// Examples:
 ///
 /// ```rust,no_run
-/// use std::ffi::CStr;
+/// use core::ffi::CStr;
 ///
 /// const HELLO: &CStr = pyo3_ffi::c_str!("hello");
 /// static WORLD: &CStr = pyo3_ffi::c_str!("world");
@@ -408,8 +419,8 @@ macro_rules! c_str {
 
 /// Private helper for `c_str!` macro.
 #[doc(hidden)]
-pub const fn _cstr_from_utf8_with_nul_checked(s: &str) -> &std::ffi::CStr {
-    match std::ffi::CStr::from_bytes_with_nul(s.as_bytes()) {
+pub const fn _cstr_from_utf8_with_nul_checked(s: &str) -> &core::ffi::CStr {
+    match core::ffi::CStr::from_bytes_with_nul(s.as_bytes()) {
         Ok(cstr) => cstr,
         Err(_) => panic!("string contains nul bytes"),
     }
diff --git a/pyo3-ffi/src/listobject.rs b/pyo3-ffi/src/listobject.rs
index d0250be81b4..ed5f1cd5f7c 100644
--- a/pyo3-ffi/src/listobject.rs
+++ b/pyo3-ffi/src/listobject.rs
@@ -1,6 +1,6 @@
 use crate::object::*;
 use crate::pyport::Py_ssize_t;
-use std::ffi::c_int;
+use core::ffi::c_int;
 
 #[cfg(not(RustPython))]
 extern_libpython! {
diff --git a/pyo3-ffi/src/longobject.rs b/pyo3-ffi/src/longobject.rs
index 5e488076e41..fda262ba0af 100644
--- a/pyo3-ffi/src/longobject.rs
+++ b/pyo3-ffi/src/longobject.rs
@@ -1,7 +1,7 @@
 use crate::object::*;
 use crate::pyport::Py_ssize_t;
+use core::ffi::{c_char, c_double, c_int, c_long, c_longlong, c_ulong, c_ulonglong, c_void};
 use libc::size_t;
-use std::ffi::{c_char, c_double, c_int, c_long, c_longlong, c_ulong, c_ulonglong, c_void};
 
 opaque_struct!(pub PyLongObject);
 
diff --git a/pyo3-ffi/src/memoryobject.rs b/pyo3-ffi/src/memoryobject.rs
index c2829459e3a..7ebc2a211d7 100644
--- a/pyo3-ffi/src/memoryobject.rs
+++ b/pyo3-ffi/src/memoryobject.rs
@@ -1,6 +1,6 @@
 use crate::object::*;
 use crate::pyport::Py_ssize_t;
-use std::ffi::{c_char, c_int};
+use core::ffi::{c_char, c_int};
 
 // skipped _PyManagedBuffer_Type
 
diff --git a/pyo3-ffi/src/methodobject.rs b/pyo3-ffi/src/methodobject.rs
index f3b8b898618..77f96903564 100644
--- a/pyo3-ffi/src/methodobject.rs
+++ b/pyo3-ffi/src/methodobject.rs
@@ -4,8 +4,8 @@ use crate::object::{PyObject, PyTypeObject};
 use crate::PyObject_TypeCheck;
 #[cfg(not(RustPython))]
 use crate::Py_IS_TYPE;
-use std::ffi::{c_char, c_int, c_void};
-use std::{mem, ptr};
+use core::ffi::{c_char, c_int, c_void};
+use core::{mem, ptr};
 
 #[cfg(all(Py_3_9, not(Py_LIMITED_API), not(GraalPy)))]
 pub struct PyCFunctionObject {
@@ -206,10 +206,10 @@ impl PartialEq for PyMethodDefPointer {
     }
 }
 
-impl std::fmt::Pointer for PyMethodDefPointer {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Pointer for PyMethodDefPointer {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         let ptr = unsafe { self.Void };
-        std::fmt::Pointer::fmt(&ptr, f)
+        core::fmt::Pointer::fmt(&ptr, f)
     }
 }
 
@@ -232,7 +232,7 @@ extern_libpython! {
 #[cfg(Py_3_9)]
 #[inline]
 pub unsafe fn PyCFunction_New(ml: *mut PyMethodDef, slf: *mut PyObject) -> *mut PyObject {
-    PyCFunction_NewEx(ml, slf, std::ptr::null_mut())
+    PyCFunction_NewEx(ml, slf, core::ptr::null_mut())
 }
 
 #[cfg(Py_3_9)]
@@ -242,7 +242,7 @@ pub unsafe fn PyCFunction_NewEx(
     slf: *mut PyObject,
     module: *mut PyObject,
 ) -> *mut PyObject {
-    PyCMethod_New(ml, slf, module, std::ptr::null_mut())
+    PyCMethod_New(ml, slf, module, core::ptr::null_mut())
 }
 
 #[cfg(Py_3_9)]
diff --git a/pyo3-ffi/src/modsupport.rs b/pyo3-ffi/src/modsupport.rs
index 4697be5bb5b..447b705f6fd 100644
--- a/pyo3-ffi/src/modsupport.rs
+++ b/pyo3-ffi/src/modsupport.rs
@@ -2,7 +2,7 @@ use crate::methodobject::PyMethodDef;
 use crate::moduleobject::PyModuleDef;
 use crate::object::PyObject;
 use crate::pyport::Py_ssize_t;
-use std::ffi::{c_char, c_int, c_long};
+use core::ffi::{c_char, c_int, c_long};
 
 extern_libpython! {
     #[cfg_attr(PyPy, link_name = "PyPyArg_Parse")]
diff --git a/pyo3-ffi/src/moduleobject.rs b/pyo3-ffi/src/moduleobject.rs
index cfc7bbd0f35..03b811d286e 100644
--- a/pyo3-ffi/src/moduleobject.rs
+++ b/pyo3-ffi/src/moduleobject.rs
@@ -3,7 +3,7 @@ use crate::object::*;
 use crate::pyport::Py_ssize_t;
 #[cfg(Py_3_15)]
 use crate::slots::PySlot;
-use std::ffi::{c_char, c_int, c_void};
+use core::ffi::{c_char, c_int, c_void};
 
 #[cfg(not(RustPython))]
 extern_libpython! {
@@ -75,7 +75,7 @@ pub const PyModuleDef_HEAD_INIT: PyModuleDef_Base = PyModuleDef_Base {
     ob_base: PyObject_HEAD_INIT,
     m_init: None,
     m_index: 0,
-    m_copy: std::ptr::null_mut(),
+    m_copy: core::ptr::null_mut(),
 };
 
 #[repr(C)]
@@ -89,7 +89,7 @@ impl Default for PyModuleDef_Slot {
     fn default() -> PyModuleDef_Slot {
         PyModuleDef_Slot {
             slot: 0,
-            value: std::ptr::null_mut(),
+            value: core::ptr::null_mut(),
         }
     }
 }
diff --git a/pyo3-ffi/src/object.rs b/pyo3-ffi/src/object.rs
index bc4a1a138b8..d3ab41757d4 100644
--- a/pyo3-ffi/src/object.rs
+++ b/pyo3-ffi/src/object.rs
@@ -5,10 +5,10 @@ use crate::refcount;
 use crate::PyMutex;
 #[cfg(Py_3_15)]
 use crate::PySlot;
-use std::ffi::{c_char, c_int, c_uint, c_ulong, c_void};
-use std::mem;
+use core::ffi::{c_char, c_int, c_uint, c_ulong, c_void};
+use core::mem;
 #[cfg(Py_GIL_DISABLED)]
-use std::sync::atomic::{AtomicIsize, AtomicU32};
+use core::sync::atomic::{AtomicIsize, AtomicU32};
 
 #[cfg(Py_LIMITED_API)]
 opaque_struct!(pub PyTypeObject);
@@ -75,8 +75,8 @@ pub union PyObjectObRefcnt {
 }
 
 #[cfg(all(Py_3_12, not(Py_GIL_DISABLED)))]
-impl std::fmt::Debug for PyObjectObRefcnt {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for PyObjectObRefcnt {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         write!(f, "{}", unsafe { self.ob_refcnt })
     }
 }
@@ -118,7 +118,7 @@ pub struct PyObject {
     pub ob_type: *mut PyTypeObject,
 }
 
-const _: () = assert!(std::mem::align_of::<PyObject>() >= _PyObject_MIN_ALIGNMENT);
+const _: () = assert!(core::mem::align_of::<PyObject>() >= _PyObject_MIN_ALIGNMENT);
 
 #[allow(
     clippy::declare_interior_mutable_const,
@@ -147,7 +147,7 @@ pub const PyObject_HEAD_INIT: PyObject = PyObject {
     ob_refcnt: 1,
     #[cfg(PyPy)]
     ob_pypy_link: 0,
-    ob_type: std::ptr::null_mut(),
+    ob_type: core::ptr::null_mut(),
 };
 
 // skipped _Py_UNOWNED_TID
@@ -718,7 +718,7 @@ pub unsafe fn PyType_HasFeature(ty: *mut PyTypeObject, feature: c_ulong) -> c_in
     let flags = PyType_GetFlags(ty);
 
     #[cfg(all(not(Py_LIMITED_API), Py_GIL_DISABLED))]
-    let flags = (*ty).tp_flags.load(std::sync::atomic::Ordering::Relaxed);
+    let flags = (*ty).tp_flags.load(core::sync::atomic::Ordering::Relaxed);
 
     #[cfg(all(not(Py_LIMITED_API), not(Py_GIL_DISABLED)))]
     let flags = (*ty).tp_flags;
diff --git a/pyo3-ffi/src/objimpl.rs b/pyo3-ffi/src/objimpl.rs
index b135d8d2155..bad80a1eae2 100644
--- a/pyo3-ffi/src/objimpl.rs
+++ b/pyo3-ffi/src/objimpl.rs
@@ -1,5 +1,5 @@
+use core::ffi::{c_int, c_void};
 use libc::size_t;
-use std::ffi::{c_int, c_void};
 
 use crate::object::*;
 use crate::pyport::Py_ssize_t;
diff --git a/pyo3-ffi/src/pybuffer.rs b/pyo3-ffi/src/pybuffer.rs
index ff9fae3100a..83975c744e1 100644
--- a/pyo3-ffi/src/pybuffer.rs
+++ b/pyo3-ffi/src/pybuffer.rs
@@ -1,7 +1,7 @@
 use crate::object::PyObject;
 use crate::pyport::Py_ssize_t;
-use std::ffi::{c_char, c_int, c_void};
-use std::ptr;
+use core::ffi::{c_char, c_int, c_void};
+use core::ptr;
 
 #[repr(C)]
 #[derive(Copy, Clone)]
diff --git a/pyo3-ffi/src/pycapsule.rs b/pyo3-ffi/src/pycapsule.rs
index 3beeb4bfafc..a5a3df91057 100644
--- a/pyo3-ffi/src/pycapsule.rs
+++ b/pyo3-ffi/src/pycapsule.rs
@@ -1,5 +1,5 @@
 use crate::object::*;
-use std::ffi::{c_char, c_int, c_void};
+use core::ffi::{c_char, c_int, c_void};
 
 #[cfg(not(RustPython))]
 extern_libpython! {
diff --git a/pyo3-ffi/src/pyerrors.rs b/pyo3-ffi/src/pyerrors.rs
index 01b15133971..505c4806a35 100644
--- a/pyo3-ffi/src/pyerrors.rs
+++ b/pyo3-ffi/src/pyerrors.rs
@@ -1,6 +1,6 @@
 use crate::object::*;
 use crate::pyport::Py_ssize_t;
-use std::ffi::{c_char, c_int};
+use core::ffi::{c_char, c_int};
 
 extern_libpython! {
     #[cfg_attr(PyPy, link_name = "PyPyErr_SetNone")]
diff --git a/pyo3-ffi/src/pyframe.rs b/pyo3-ffi/src/pyframe.rs
index cce6fe2f17e..fca98ac5cbe 100644
--- a/pyo3-ffi/src/pyframe.rs
+++ b/pyo3-ffi/src/pyframe.rs
@@ -2,7 +2,7 @@
 #[cfg(any(Py_3_10, all(Py_3_9, not(Py_LIMITED_API))))]
 use crate::PyCodeObject;
 use crate::PyFrameObject;
-use std::ffi::c_int;
+use core::ffi::c_int;
 
 extern_libpython! {
     pub fn PyFrame_GetLineNumber(frame: *mut PyFrameObject) -> c_int;
diff --git a/pyo3-ffi/src/pyhash.rs b/pyo3-ffi/src/pyhash.rs
index b96c40a11e5..ca39071dbbf 100644
--- a/pyo3-ffi/src/pyhash.rs
+++ b/pyo3-ffi/src/pyhash.rs
@@ -1,9 +1,9 @@
 #[cfg(not(any(Py_LIMITED_API, PyPy)))]
 use crate::pyport::{Py_hash_t, Py_ssize_t};
 #[cfg(not(any(Py_LIMITED_API, PyPy)))]
-use std::ffi::c_void;
+use core::ffi::c_void;
 
-use std::ffi::{c_int, c_ulong};
+use core::ffi::{c_int, c_ulong};
 
 extern_libpython! {
     // skipped non-limited _Py_HashDouble
diff --git a/pyo3-ffi/src/pylifecycle.rs b/pyo3-ffi/src/pylifecycle.rs
index cf7b105e8d4..758f5228f61 100644
--- a/pyo3-ffi/src/pylifecycle.rs
+++ b/pyo3-ffi/src/pylifecycle.rs
@@ -1,7 +1,7 @@
 use crate::pytypedefs::PyThreadState;
 
+use core::ffi::{c_char, c_int};
 use libc::wchar_t;
-use std::ffi::{c_char, c_int};
 
 extern_libpython! {
     pub fn Py_Initialize();
@@ -97,7 +97,7 @@ extern_libpython! {
     pub fn PyOS_setsig(arg1: c_int, arg2: PyOS_sighandler_t) -> PyOS_sighandler_t;
 
     #[cfg(Py_3_11)]
-    pub static Py_Version: std::ffi::c_ulong;
+    pub static Py_Version: core::ffi::c_ulong;
 
     #[cfg(Py_3_13)]
     pub fn Py_IsFinalizing() -> c_int;
diff --git a/pyo3-ffi/src/pymem.rs b/pyo3-ffi/src/pymem.rs
index 9654c7246f0..45e57ef1db6 100644
--- a/pyo3-ffi/src/pymem.rs
+++ b/pyo3-ffi/src/pymem.rs
@@ -1,5 +1,5 @@
+use core::ffi::c_void;
 use libc::size_t;
-use std::ffi::c_void;
 
 extern_libpython! {
     #[cfg_attr(PyPy, link_name = "PyPyMem_Malloc")]
diff --git a/pyo3-ffi/src/pyport.rs b/pyo3-ffi/src/pyport.rs
index 3a066353ca4..db102368ecf 100644
--- a/pyo3-ffi/src/pyport.rs
+++ b/pyo3-ffi/src/pyport.rs
@@ -1,7 +1,7 @@
 // NB libc does not define this constant on all platforms, so we hard code it
 // like CPython does.
 // https://github.com/python/cpython/blob/d8b9011702443bb57579f8834f3effe58e290dfc/Include/pyport.h#L372
-pub const INT_MAX: std::ffi::c_int = 2147483647;
+pub const INT_MAX: core::ffi::c_int = 2147483647;
 
 pub type PY_UINT32_T = u32;
 pub type PY_UINT64_T = u64;
diff --git a/pyo3-ffi/src/pystate.rs b/pyo3-ffi/src/pystate.rs
index 381862964b5..5bb821db9a5 100644
--- a/pyo3-ffi/src/pystate.rs
+++ b/pyo3-ffi/src/pystate.rs
@@ -1,14 +1,14 @@
 use crate::moduleobject::PyModuleDef;
 use crate::object::PyObject;
 use crate::pytypedefs::{PyInterpreterState, PyThreadState};
-use std::ffi::c_int;
+use core::ffi::c_int;
 
 #[cfg(any(all(Py_3_9, not(Py_LIMITED_API)), Py_3_10))]
 #[cfg(not(PyPy))]
 use crate::PyFrameObject;
 
 #[cfg(not(PyPy))]
-use std::ffi::c_long;
+use core::ffi::c_long;
 
 pub const MAX_CO_EXTRA_USERS: c_int = 255;
 
@@ -135,7 +135,7 @@ pub unsafe extern "C" fn PyGILState_Ensure() -> PyGILState_STATE {
     // nothing we can do it other than waiting for Python 3.14 or not using Windows. At least,
     // if there is nothing pinned on the stack, it won't cause the process to crash.
     let ret: PyGILState_STATE = raw::PyGILState_Ensure();
-    std::mem::forget(guard);
+    core::mem::forget(guard);
     ret
 }
 
diff --git a/pyo3-ffi/src/pystrtod.rs b/pyo3-ffi/src/pystrtod.rs
index e890896d41d..43ac27b26cd 100644
--- a/pyo3-ffi/src/pystrtod.rs
+++ b/pyo3-ffi/src/pystrtod.rs
@@ -1,5 +1,5 @@
 use crate::object::PyObject;
-use std::ffi::{c_char, c_double, c_int};
+use core::ffi::{c_char, c_double, c_int};
 
 extern_libpython! {
     #[cfg_attr(PyPy, link_name = "PyPyOS_string_to_double")]
diff --git a/pyo3-ffi/src/pythonrun.rs b/pyo3-ffi/src/pythonrun.rs
index df9095c670e..91c12a1931c 100644
--- a/pyo3-ffi/src/pythonrun.rs
+++ b/pyo3-ffi/src/pythonrun.rs
@@ -1,9 +1,9 @@
 use crate::object::*;
+#[cfg(any(Py_LIMITED_API, not(Py_3_10), PyPy, GraalPy))]
+use core::ffi::c_char;
+use core::ffi::c_int;
 #[cfg(not(any(PyPy, Py_LIMITED_API, Py_3_10)))]
 use libc::FILE;
-#[cfg(any(Py_LIMITED_API, not(Py_3_10), PyPy, GraalPy))]
-use std::ffi::c_char;
-use std::ffi::c_int;
 
 extern_libpython! {
     #[cfg(any(all(Py_LIMITED_API, not(PyPy)), GraalPy))]
@@ -33,13 +33,13 @@ pub unsafe fn Py_CompileString(string: *const c_char, p: *const c_char, s: c_int
             string: *const c_char,
             p: *const c_char,
             s: c_int,
-            f: *mut std::ffi::c_void, // Actually *mut Py_CompilerFlags in the real definition
+            f: *mut core::ffi::c_void, // Actually *mut Py_CompilerFlags in the real definition
         ) -> *mut PyObject;
     }
     #[cfg(not(Py_LIMITED_API))]
     use crate::Py_CompileStringFlags;
 
-    Py_CompileStringFlags(string, p, s, std::ptr::null_mut())
+    Py_CompileStringFlags(string, p, s, core::ptr::null_mut())
 }
 
 // skipped PyOS_InputHook
diff --git a/pyo3-ffi/src/rangeobject.rs b/pyo3-ffi/src/rangeobject.rs
index b1e0318a178..ffecd07eb32 100644
--- a/pyo3-ffi/src/rangeobject.rs
+++ b/pyo3-ffi/src/rangeobject.rs
@@ -1,5 +1,5 @@
 use crate::object::*;
-use std::ffi::c_int;
+use core::ffi::c_int;
 
 extern_libpython! {
     #[cfg(not(RustPython))]
diff --git a/pyo3-ffi/src/refcount.rs b/pyo3-ffi/src/refcount.rs
index d404660b03a..232d1d6b2d2 100644
--- a/pyo3-ffi/src/refcount.rs
+++ b/pyo3-ffi/src/refcount.rs
@@ -1,18 +1,18 @@
 use crate::pyport::Py_ssize_t;
 use crate::PyObject;
 #[cfg(all(not(Py_LIMITED_API), py_sys_config = "Py_REF_DEBUG"))]
-use std::ffi::c_char;
+use core::ffi::c_char;
 #[cfg(any(Py_3_12, all(py_sys_config = "Py_REF_DEBUG", not(Py_LIMITED_API))))]
-use std::ffi::c_int;
+use core::ffi::c_int;
 #[cfg(all(Py_3_14, any(not(Py_GIL_DISABLED), target_pointer_width = "32")))]
-use std::ffi::c_long;
+use core::ffi::c_long;
 #[cfg(any(Py_GIL_DISABLED, all(Py_3_12, not(Py_3_14))))]
-use std::ffi::c_uint;
+use core::ffi::c_uint;
 #[cfg(all(Py_3_14, not(Py_GIL_DISABLED)))]
-use std::ffi::c_ulong;
-use std::ptr;
+use core::ffi::c_ulong;
+use core::ptr;
 #[cfg(Py_GIL_DISABLED)]
-use std::sync::atomic::Ordering::Relaxed;
+use core::sync::atomic::Ordering::Relaxed;
 
 #[cfg(all(Py_3_14, not(Py_3_15)))]
 const _Py_STATICALLY_ALLOCATED_FLAG: c_int = 1 << 7;
@@ -298,8 +298,8 @@ pub unsafe fn Py_DECREF(op: *mut PyObject) {
 
             #[cfg(py_sys_config = "Py_REF_DEBUG")]
             if (*op).ob_refcnt.ob_refcnt < 0 {
-                let location = std::panic::Location::caller();
-                let filename = std::ffi::CString::new(location.file()).unwrap();
+                let location = core::panic::Location::caller();
+                let filename = alloc::ffi::CString::new(location.file()).unwrap();
                 _Py_NegativeRefcount(filename.as_ptr(), location.line() as i32, op);
             }
 
diff --git a/pyo3-ffi/src/setobject.rs b/pyo3-ffi/src/setobject.rs
index 42f5247791b..8fcb3006fcc 100644
--- a/pyo3-ffi/src/setobject.rs
+++ b/pyo3-ffi/src/setobject.rs
@@ -2,7 +2,7 @@ use crate::object::*;
 #[cfg(not(any(Py_LIMITED_API, PyPy, GraalPy)))]
 use crate::pyport::Py_hash_t;
 use crate::pyport::Py_ssize_t;
-use std::ffi::c_int;
+use core::ffi::c_int;
 
 pub const PySet_MINSIZE: usize = 8;
 
diff --git a/pyo3-ffi/src/sliceobject.rs b/pyo3-ffi/src/sliceobject.rs
index bab7a0a3338..175a65f0622 100644
--- a/pyo3-ffi/src/sliceobject.rs
+++ b/pyo3-ffi/src/sliceobject.rs
@@ -1,6 +1,6 @@
 use crate::object::*;
 use crate::pyport::Py_ssize_t;
-use std::ffi::c_int;
+use core::ffi::c_int;
 
 extern_libpython! {
     #[cfg(all(not(GraalPy), not(all(Py_3_13, Py_LIMITED_API))))]
diff --git a/pyo3-ffi/src/slots.rs b/pyo3-ffi/src/slots.rs
index 2bb214ad7ea..0a023ec4079 100644
--- a/pyo3-ffi/src/slots.rs
+++ b/pyo3-ffi/src/slots.rs
@@ -1,7 +1,7 @@
 #[cfg(Py_3_15)]
 use crate::Py_ssize_t;
 #[cfg(Py_3_15)]
-use std::ffi::{c_int, c_void};
+use core::ffi::{c_int, c_void};
 
 #[cfg(Py_3_15)]
 pub type _Py_funcptr_t = unsafe extern "C" fn();
@@ -78,7 +78,7 @@ pub const unsafe fn PySlot_FUNC(NAME: c_int, VALUE: *mut c_void) -> PySlot {
         sl_flags: 0,
         anon1: _anon_union_32b { sl_reserved: 0 },
         anon2: _anon_union_64b {
-            sl_func: Some(unsafe { std::mem::transmute::<*mut c_void, _Py_funcptr_t>(VALUE) }),
+            sl_func: Some(unsafe { core::mem::transmute::<*mut c_void, _Py_funcptr_t>(VALUE) }),
         },
     }
 }
@@ -145,5 +145,5 @@ pub const fn PySlot_PTR_STATIC(NAME: c_int, VALUE: *mut c_void) -> PySlot {
 
 #[cfg(Py_3_15)]
 pub const fn PySlot_END() -> PySlot {
-    unsafe { std::mem::zeroed() }
+    unsafe { core::mem::zeroed() }
 }
diff --git a/pyo3-ffi/src/slots_generated.rs b/pyo3-ffi/src/slots_generated.rs
index b6af4beaae6..ef46e398f4c 100644
--- a/pyo3-ffi/src/slots_generated.rs
+++ b/pyo3-ffi/src/slots_generated.rs
@@ -1,4 +1,4 @@
-use std::ffi::c_int;
+use core::ffi::c_int;
 
 #[allow(unused_variables)]
 const fn _Py_SLOT_COMPAT_VALUE(OLD: c_int, NEW: c_int) -> c_int {
diff --git a/pyo3-ffi/src/structmember.rs b/pyo3-ffi/src/structmember.rs
index 4aa6c24db4f..7b2948272a6 100644
--- a/pyo3-ffi/src/structmember.rs
+++ b/pyo3-ffi/src/structmember.rs
@@ -1,4 +1,4 @@
-use std::ffi::c_int;
+use core::ffi::c_int;
 
 pub use crate::PyMemberDef;
 
diff --git a/pyo3-ffi/src/structseq.rs b/pyo3-ffi/src/structseq.rs
index 70a97f5b215..7a1a70015a8 100644
--- a/pyo3-ffi/src/structseq.rs
+++ b/pyo3-ffi/src/structseq.rs
@@ -1,7 +1,7 @@
 use crate::object::{PyObject, PyTypeObject};
 #[cfg(not(PyPy))]
 use crate::pyport::Py_ssize_t;
-use std::ffi::{c_char, c_int};
+use core::ffi::{c_char, c_int};
 
 #[repr(C)]
 #[derive(Copy, Clone)]
diff --git a/pyo3-ffi/src/sysmodule.rs b/pyo3-ffi/src/sysmodule.rs
index 4018d764724..d5c2bebdf8c 100644
--- a/pyo3-ffi/src/sysmodule.rs
+++ b/pyo3-ffi/src/sysmodule.rs
@@ -1,6 +1,6 @@
 use crate::object::PyObject;
+use core::ffi::{c_char, c_int};
 use libc::wchar_t;
-use std::ffi::{c_char, c_int};
 
 extern_libpython! {
     #[cfg_attr(PyPy, link_name = "PyPySys_GetObject")]
diff --git a/pyo3-ffi/src/traceback.rs b/pyo3-ffi/src/traceback.rs
index b286f5520b9..9cfb11dcb9d 100644
--- a/pyo3-ffi/src/traceback.rs
+++ b/pyo3-ffi/src/traceback.rs
@@ -1,5 +1,5 @@
 use crate::object::*;
-use std::ffi::c_int;
+use core::ffi::c_int;
 
 extern_libpython! {
     #[cfg_attr(PyPy, link_name = "PyPyTraceBack_Here")]
diff --git a/pyo3-ffi/src/tupleobject.rs b/pyo3-ffi/src/tupleobject.rs
index 253ac91b19a..e415eabfe66 100644
--- a/pyo3-ffi/src/tupleobject.rs
+++ b/pyo3-ffi/src/tupleobject.rs
@@ -1,6 +1,6 @@
 use crate::object::*;
 use crate::pyport::Py_ssize_t;
-use std::ffi::c_int;
+use core::ffi::c_int;
 
 #[cfg(not(RustPython))]
 extern_libpython! {
diff --git a/pyo3-ffi/src/unicodeobject.rs b/pyo3-ffi/src/unicodeobject.rs
index 03d62b870b2..e4a78f8caee 100644
--- a/pyo3-ffi/src/unicodeobject.rs
+++ b/pyo3-ffi/src/unicodeobject.rs
@@ -1,7 +1,7 @@
 use crate::object::*;
 use crate::pyport::Py_ssize_t;
+use core::ffi::{c_char, c_int, c_void};
 use libc::wchar_t;
-use std::ffi::{c_char, c_int, c_void};
 
 #[cfg(not(Py_LIMITED_API))]
 #[cfg_attr(
diff --git a/pyo3-ffi/src/warnings.rs b/pyo3-ffi/src/warnings.rs
index 169e3a54819..4277c4daf84 100644
--- a/pyo3-ffi/src/warnings.rs
+++ b/pyo3-ffi/src/warnings.rs
@@ -1,6 +1,6 @@
 use crate::object::PyObject;
 use crate::pyport::Py_ssize_t;
-use std::ffi::{c_char, c_int};
+use core::ffi::{c_char, c_int};
 
 extern_libpython! {
     #[cfg_attr(PyPy, link_name = "PyPyErr_WarnEx")]
diff --git a/pyo3-ffi/src/weakrefobject.rs b/pyo3-ffi/src/weakrefobject.rs
index ff6123e84fd..84b94125ca7 100644
--- a/pyo3-ffi/src/weakrefobject.rs
+++ b/pyo3-ffi/src/weakrefobject.rs
@@ -1,5 +1,5 @@
 use crate::object::*;
-use std::ffi::c_int;
+use core::ffi::c_int;
 
 #[cfg(all(not(PyPy), Py_LIMITED_API, not(GraalPy)))]
 opaque_struct!(pub PyWeakReference);