Initial free threaded bindings

.github/workflows/ci.yml

@@ -489,6 +489,35 @@ jobs:
           echo PYO3_CONFIG_FILE=$PYO3_CONFIG_FILE >> $GITHUB_ENV
       - run: python3 -m nox -s test
 
+  test-free-threaded:
+    if: ${{ contains(github.event.pull_request.labels.*.name, 'CI-build-full') || github.event_name != 'pull_request' }}
+    needs: [fmt]
+    runs-on: ubuntu-latest
+    env:
+      UNSAFE_PYO3_BUILD_FREE_THREADED: 1
+    steps:
+      - uses: actions/checkout@v4
+      - uses: Swatinem/rust-cache@v2
+        with:
+          save-if: ${{ github.event_name != 'merge_group' }}
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          components: rust-src
+      # TODO: replace with setup-python when there is support
+      - uses: deadsnakes/[email protected]
+        with:
+          python-version: '3.13-dev'
+          nogil: true
+      - run: python3 -m sysconfig
+      - run: python3 -m pip install --upgrade pip && pip install nox
+      - run: nox -s ffi-check
+      - name: Run default nox sessions that should pass
+        run: nox -s clippy docs rustfmt ruff
+      - name: Run PyO3 tests with free-threaded Python (can fail)
+        # TODO fix the test crashes so we can unset this
+        continue-on-error: true
+        run: nox -s test
+
   test-version-limits:
     needs: [fmt]
     if: ${{ contains(github.event.pull_request.labels.*.name, 'CI-build-full') || github.event_name != 'pull_request' }}
@@ -627,6 +656,7 @@ jobs:
       - coverage
       - emscripten
       - test-debug
+      - test-free-threaded
       - test-version-limits
       - check-feature-powerset
       - test-cross-compilation

examples/sequential/src/module.rs

@@ -3,7 +3,7 @@ use pyo3_ffi::*;
 use std::os::raw::{c_int, c_void};
 
 pub static mut MODULE_DEF: PyModuleDef = PyModuleDef {
-    m_base: PyModuleDef_HEAD_INIT,
+    m_base: PyModuleDef_HEAD_INIT(),
     m_name: c_str!("sequential").as_ptr(),
     m_doc: c_str!("A library for generating sequential ids, written in Rust.").as_ptr(),
     m_size: mem::size_of::<sequential_state>() as Py_ssize_t,

examples/string-sum/src/lib.rs

@@ -4,7 +4,7 @@ use std::ptr;
 use pyo3_ffi::*;
 
 static mut MODULE_DEF: PyModuleDef = PyModuleDef {
-    m_base: PyModuleDef_HEAD_INIT,
+    m_base: PyModuleDef_HEAD_INIT(),
     m_name: c_str!("string_sum").as_ptr(),
     m_doc: c_str!("A Python module written in Rust.").as_ptr(),
     m_size: 0,

pyo3-build-config/src/impl_.rs

@@ -177,12 +177,19 @@ impl InterpreterConfig {
             PythonImplementation::GraalPy => out.push("cargo:rustc-cfg=GraalPy".to_owned()),
         }
 
-        if self.abi3 {
+        // If Py_GIL_DISABLED is set, do not build with limited API support
+        if self.abi3 && !self.build_flags.0.contains(&BuildFlag::Py_GIL_DISABLED) {
             out.push("cargo:rustc-cfg=Py_LIMITED_API".to_owned());
         }
 
+        if self.build_flags.0.contains(&BuildFlag::Py_GIL_DISABLED) {
+            out.push("cargo:rustc-cfg=Py_GIL_DISABLED".to_owned());
+        }
+
         for flag in &self.build_flags.0 {
-            out.push(format!("cargo:rustc-cfg=py_sys_config=\"{}\"", flag));
+            if flag != &BuildFlag::Py_GIL_DISABLED {
+                out.push(format!("cargo:rustc-cfg=py_sys_config=\"{}\"", flag));
+            }
         }
 
         out
@@ -321,6 +328,8 @@ print("ext_suffix", get_config_var("EXT_SUFFIX"))
             .parse()
             .context("failed to parse calcsize_pointer")?;
 
+        let build_flags: BuildFlags = BuildFlags::from_interpreter(interpreter)?;
+
         Ok(InterpreterConfig {
             version,
             implementation,
@@ -330,7 +339,7 @@ print("ext_suffix", get_config_var("EXT_SUFFIX"))
             lib_dir,
             executable: map.get("executable").cloned(),
             pointer_width: Some(calcsize_pointer * 8),
-            build_flags: BuildFlags::from_interpreter(interpreter)?,
+            build_flags,
             suppress_build_script_link_lines: false,
             extra_build_script_lines: vec![],
         })
@@ -484,6 +493,8 @@ print("ext_suffix", get_config_var("EXT_SUFFIX"))
             }
         });
 
+        let build_flags: BuildFlags = build_flags.unwrap_or_default();
+
         Ok(InterpreterConfig {
             implementation,
             version,
@@ -493,7 +504,7 @@ print("ext_suffix", get_config_var("EXT_SUFFIX"))
             lib_dir,
             executable,
             pointer_width,
-            build_flags: build_flags.unwrap_or_default(),
+            build_flags,
             suppress_build_script_link_lines: suppress_build_script_link_lines.unwrap_or(false),
             extra_build_script_lines,
         })
@@ -2733,6 +2744,43 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_build_script_outputs_gil_disabled() {
+        let mut build_flags = BuildFlags::default();
+        build_flags.0.insert(BuildFlag::Py_GIL_DISABLED);
+        let interpreter_config = InterpreterConfig {
+            implementation: PythonImplementation::CPython,
+            version: PythonVersion {
+                major: 3,
+                minor: 13,
+            },
+            shared: true,
+            abi3: false,
+            lib_name: Some("python3".into()),
+            lib_dir: None,
+            executable: None,
+            pointer_width: None,
+            build_flags,
+            suppress_build_script_link_lines: false,
+            extra_build_script_lines: vec![],
+        };
+
+        assert_eq!(
+            interpreter_config.build_script_outputs(),
+            [
+                "cargo:rustc-cfg=Py_3_6".to_owned(),
+                "cargo:rustc-cfg=Py_3_7".to_owned(),
+                "cargo:rustc-cfg=Py_3_8".to_owned(),
+                "cargo:rustc-cfg=Py_3_9".to_owned(),
+                "cargo:rustc-cfg=Py_3_10".to_owned(),
+                "cargo:rustc-cfg=Py_3_11".to_owned(),
+                "cargo:rustc-cfg=Py_3_12".to_owned(),
+                "cargo:rustc-cfg=Py_3_13".to_owned(),
+                "cargo:rustc-cfg=Py_GIL_DISABLED".to_owned(),
+            ]
+        );
+    }
+
     #[test]
     fn test_build_script_outputs_debug() {
         let mut build_flags = BuildFlags::default();

pyo3-build-config/src/lib.rs

@@ -166,6 +166,7 @@ pub fn print_expected_cfgs() {
     }
 
     println!("cargo:rustc-check-cfg=cfg(Py_LIMITED_API)");
+    println!("cargo:rustc-check-cfg=cfg(Py_GIL_DISABLED)");
     println!("cargo:rustc-check-cfg=cfg(PyPy)");
     println!("cargo:rustc-check-cfg=cfg(GraalPy)");
     println!("cargo:rustc-check-cfg=cfg(py_sys_config, values(\"Py_DEBUG\", \"Py_REF_DEBUG\", \"Py_TRACE_REFS\", \"COUNT_ALLOCS\"))");

pyo3-ffi/README.md

@@ -50,7 +50,7 @@ use std::ptr;
 use pyo3_ffi::*;
 
 static mut MODULE_DEF: PyModuleDef = PyModuleDef {
-    m_base: PyModuleDef_HEAD_INIT,
+    m_base: PyModuleDef_HEAD_INIT(),
     m_name: c_str!("string_sum").as_ptr(),
     m_doc: c_str!("A Python module written in Rust.").as_ptr(),
     m_size: 0,

pyo3-ffi/build.rs

@@ -135,6 +135,11 @@ fn ensure_gil_enabled(interpreter_config: &InterpreterConfig) -> Result<()> {
         = help: set UNSAFE_PYO3_BUILD_FREE_THREADED=1 to suppress this check and build anyway for free-threaded Python",
         std::env::var("CARGO_PKG_VERSION").unwrap()
     );
+    if interpreter_config.abi3 {
+        warn!(
+            "The free-threaded build of CPython does not yet support abi3 so the build artifacts will be version-specific."
+        )
+    }
 
     Ok(())
 }

pyo3-ffi/src/cpython/initconfig.rs

@@ -143,6 +143,8 @@ pub struct PyConfig {
     pub int_max_str_digits: c_int,
     #[cfg(Py_3_13)]
     pub cpu_count: c_int,
+    #[cfg(Py_GIL_DISABLED)]
+    pub enable_gil: c_int,
     pub pathconfig_warnings: c_int,
     #[cfg(Py_3_10)]
     pub program_name: *mut wchar_t,
@@ -177,6 +179,8 @@ pub struct PyConfig {
     pub _is_python_build: c_int,
     #[cfg(all(Py_3_9, not(Py_3_10)))]
     pub _orig_argv: PyWideStringList,
+    #[cfg(all(Py_3_13, py_sys_config = "Py_DEBUG"))]
+    pub run_presite: *mut wchar_t,
 }
 
 extern "C" {

pyo3-ffi/src/cpython/lock.rs

@@ -0,0 +1,18 @@
+use std::fmt;
+use std::sync::atomic::AtomicU8;
+
+#[repr(C)]
+pub struct PyMutex {
+    _bits: AtomicU8,
+}
+
+impl fmt::Debug for PyMutex {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("PyMutex").finish()
+    }
+}
+
+extern "C" {
+    pub fn PyMutex_Lock(m: *mut PyMutex);
+    pub fn PyMutex_UnLock(m: *mut PyMutex);
+}

pyo3-ffi/src/cpython/mod.rs

@@ -18,6 +18,8 @@ pub(crate) mod import;
 pub(crate) mod initconfig;
 // skipped interpreteridobject.h
 pub(crate) mod listobject;
+#[cfg(Py_3_13)]
+pub(crate) mod lock;
 pub(crate) mod longobject;
 #[cfg(all(Py_3_9, not(PyPy)))]
 pub(crate) mod methodobject;
@@ -54,6 +56,8 @@ pub use self::import::*;
 #[cfg(all(Py_3_8, not(PyPy)))]
 pub use self::initconfig::*;
 pub use self::listobject::*;
+#[cfg(Py_3_13)]
+pub use self::lock::*;
 pub use self::longobject::*;
 #[cfg(all(Py_3_9, not(PyPy)))]
 pub use self::methodobject::*;

pyo3-ffi/src/cpython/weakrefobject.rs

@@ -8,6 +8,8 @@ pub struct _PyWeakReference {
     pub wr_next: *mut crate::PyWeakReference,
     #[cfg(Py_3_11)]
     pub vectorcall: Option<crate::vectorcallfunc>,
+    #[cfg(all(Py_3_13, Py_GIL_DISABLED))]
+    pub weakrefs_lock: *mut crate::PyMutex,
 }
 
 // skipped _PyWeakref_GetWeakrefCount

pyo3-ffi/src/lib.rs

@@ -88,7 +88,7 @@
 //! use pyo3_ffi::*;
 //!
 //! static mut MODULE_DEF: PyModuleDef = PyModuleDef {
-//!     m_base: PyModuleDef_HEAD_INIT,
+//!     m_base: PyModuleDef_HEAD_INIT(),
 //!     m_name: c_str!("string_sum").as_ptr(),
 //!     m_doc: c_str!("A Python module written in Rust.").as_ptr(),
 //!     m_size: 0,

pyo3-ffi/src/moduleobject.rs

@@ -59,12 +59,14 @@ pub struct PyModuleDef_Base {
     pub m_copy: *mut PyObject,
 }
 
-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(),
-};
+pub const fn PyModuleDef_HEAD_INIT() -> PyModuleDef_Base {
+    PyModuleDef_Base {
+        ob_base: PyObject_HEAD_INIT(),
+        m_init: None,
+        m_index: 0,
+        m_copy: std::ptr::null_mut(),
+    }
+}
 
 #[repr(C)]
 #[derive(Copy, Clone, Eq, PartialEq)]