Require Python 3.14+ for OWN_GIL mode

OWN_GIL mode is disabled on Python < 3.14 due to C extension global
state bugs (e.g., _decimal). See python/cpython#106078

Changes:
- Add HAVE_OWNGIL compile flag (Python 3.14+)
- Add py_nif:owngil_supported/0 NIF
- Update py_context and py_event_loop_pool to check owngil_supported
- Update OWN_GIL test suites to skip on Python < 3.14
- Add Python 3.14 to CI matrix and ASAN tests

Author: benoitc

.github/workflows/ci.yml

@@ -22,13 +22,19 @@ jobs:
           - os: ubuntu-24.04
             otp: "27.0"
             python: "3.13"
+          - os: ubuntu-24.04
+            otp: "27.0"
+            python: "3.14"
           # macOS
           - os: macos-15
             otp: "27"
             python: "3.12"
           - os: macos-15
             otp: "27"
             python: "3.13"
+          - os: macos-15
+            otp: "27"
+            python: "3.14"
 
     steps:
       - name: Checkout
@@ -194,7 +200,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        python: ["3.12", "3.13"]
+        python: ["3.12", "3.13", "3.14"]
 
     steps:
       - name: Checkout

c_src/CMakeLists.txt

@@ -159,12 +159,23 @@ int main(void) {
 
     if(HAVE_SUBINTERPRETERS)
         message(STATUS "Subinterpreter API detected (PyInterpreterConfig_OWN_GIL available)")
+        # OWN_GIL mode requires Python 3.14+ due to C extension global state bugs
+        # in 3.12/3.13 (e.g., _decimal). See https://github.com/python/cpython/issues/106078
+        if(Python3_VERSION VERSION_GREATER_EQUAL "3.14")
+            set(HAVE_OWNGIL TRUE)
+            message(STATUS "Python ${Python3_VERSION} >= 3.14, OWN_GIL mode enabled")
+        else()
+            set(HAVE_OWNGIL FALSE)
+            message(STATUS "Python ${Python3_VERSION} < 3.14, OWN_GIL mode disabled (C extension bugs)")
+        endif()
     else()
         message(STATUS "Subinterpreter API compile test failed, using shared GIL fallback")
+        set(HAVE_OWNGIL FALSE)
     endif()
 else()
     message(STATUS "Python ${Python3_VERSION} < 3.12, subinterpreter API not available")
     set(HAVE_SUBINTERPRETERS FALSE)
+    set(HAVE_OWNGIL FALSE)
 endif()
 
 # Check for free-threaded Python (Python 3.13+ with --disable-gil / nogil build)
@@ -201,6 +212,9 @@ endif()
 if(HAVE_SUBINTERPRETERS)
     target_compile_definitions(py_nif PRIVATE HAVE_SUBINTERPRETERS=1)
 endif()
+if(HAVE_OWNGIL)
+    target_compile_definitions(py_nif PRIVATE HAVE_OWNGIL=1)
+endif()
 if(HAVE_FREE_THREADED)
     target_compile_definitions(py_nif PRIVATE HAVE_FREE_THREADED=1)
 endif()

c_src/py_nif.c

@@ -1970,6 +1970,23 @@ static ERL_NIF_TERM nif_subinterp_supported(ErlNifEnv *env, int argc, const ERL_
 #endif
 }
 
+/**
+ * @brief Check if OWN_GIL mode is supported (Python 3.14+)
+ *
+ * OWN_GIL requires Python 3.14+ due to C extension global state bugs
+ * in earlier versions (e.g., _decimal). See gh-106078.
+ */
+static ERL_NIF_TERM nif_owngil_supported(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    (void)argc;
+    (void)argv;
+
+#ifdef HAVE_OWNGIL
+    return ATOM_TRUE;
+#else
+    return ATOM_FALSE;
+#endif
+}
+
 #ifdef HAVE_SUBINTERPRETERS
 
 static ERL_NIF_TERM nif_subinterp_worker_new(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
@@ -7130,6 +7147,7 @@ static ErlNifFunc nif_funcs[] = {
 
     /* Sub-interpreter support (shared GIL pool model) */
     {"subinterp_supported", 0, nif_subinterp_supported, 0},
+    {"owngil_supported", 0, nif_owngil_supported, 0},
     {"subinterp_worker_new", 0, nif_subinterp_worker_new, 0},
     {"subinterp_worker_destroy", 1, nif_subinterp_worker_destroy, 0},
     {"subinterp_call", 5, nif_subinterp_call, ERL_NIF_DIRTY_JOB_CPU_BOUND},

src/py_context.erl

@@ -531,10 +531,10 @@ create_context(subinterp) ->
 create_context(worker) ->
     py_nif:context_create(worker);
 create_context(owngil) ->
-    %% OWN_GIL mode requires Python 3.12+
-    case py_nif:subinterp_supported() of
+    %% OWN_GIL mode requires Python 3.14+ due to C extension bugs in earlier versions
+    case py_nif:owngil_supported() of
         true -> py_nif:context_create(owngil);
-        false -> {error, owngil_requires_python312}
+        false -> {error, owngil_requires_python314}
     end.
 
 %% @private

src/py_event_loop_pool.erl

@@ -370,8 +370,9 @@ run_async(Request) ->
 init([NumLoops]) ->
     process_flag(trap_exit, true),
 
-    %% Check if OWN_GIL mode is enabled
-    OwnGilEnabled = application:get_env(erlang_python, event_loop_pool_owngil, false),
+    %% Check if OWN_GIL mode is enabled and supported (Python 3.14+)
+    OwnGilConfigured = application:get_env(erlang_python, event_loop_pool_owngil, false),
+    OwnGilEnabled = OwnGilConfigured andalso py_nif:owngil_supported(),
 
     %% Initialize OWN_GIL infrastructure if enabled
     {Sessions, OwnGilReady} = case OwnGilEnabled of

src/py_nif.erl

@@ -54,6 +54,7 @@
     async_stream/6,
     %% Sub-interpreters (Python 3.12+) - shared GIL pool model
     subinterp_supported/0,
+    owngil_supported/0,
     subinterp_worker_new/0,
     subinterp_worker_destroy/1,
     subinterp_call/5,
@@ -490,6 +491,13 @@ async_stream(_WorkerRef, _Module, _Func, _Args, _Kwargs, _CallerPid) ->
 subinterp_supported() ->
     ?NIF_STUB.
 
+%% @doc Check if OWN_GIL mode is supported (Python 3.14+).
+%% OWN_GIL requires Python 3.14+ due to C extension global state bugs
+%% in earlier versions (e.g., _decimal). See gh-106078.
+-spec owngil_supported() -> boolean().
+owngil_supported() ->
+    ?NIF_STUB.
+
 %% @doc Create a new sub-interpreter worker with its own GIL.
 %% Returns an opaque reference to be used with subinterp functions.
 -spec subinterp_worker_new() -> {ok, reference()} | {error, term()}.

test/py_context_owngil_SUITE.erl

@@ -96,12 +96,12 @@ groups() ->
     ]}].
 
 init_per_suite(Config) ->
-    case py_nif:subinterp_supported() of
+    case py_nif:owngil_supported() of
         true ->
             {ok, _} = application:ensure_all_started(erlang_python),
             Config;
         false ->
-            {skip, "Requires Python 3.12+"}
+            {skip, "OWN_GIL requires Python 3.14+"}
     end.
 
 end_per_suite(_Config) ->

test/py_import_SUITE.erl

@@ -540,10 +540,10 @@ def encode_test(data):
 %% OWN_GIL contexts each have their own interpreter, so imports in one
 %% should NOT be visible in another (different sys.modules).
 subinterp_isolation_test(_Config) ->
-    %% Skip if subinterpreters not supported
-    case py_nif:subinterp_supported() of
+    %% Skip if OWN_GIL not supported (requires Python 3.14+)
+    case py_nif:owngil_supported() of
         false ->
-            {skip, "Subinterpreters not supported"};
+            {skip, "OWN_GIL requires Python 3.14+"};
         true ->
             %% Clear registry so new contexts don't get pre-imported modules
             ok = py_import:clear_imports(),

test/py_import_owngil_SUITE.erl

@@ -68,12 +68,12 @@ init_per_suite(Config) ->
     %% Clear any imports from previous test suites to avoid
     %% importing C extensions that crash in OWN_GIL subinterpreters
     py_import:clear_imports(),
-    %% Then check if subinterpreters are supported
-    case py_nif:subinterp_supported() of
+    %% Check if OWN_GIL is supported (requires Python 3.14+)
+    case py_nif:owngil_supported() of
         true ->
             Config;
         false ->
-            {skip, "Requires Python 3.12+"}
+            {skip, "OWN_GIL requires Python 3.14+"}
     end.
 
 end_per_suite(_Config) ->

test/py_owngil_features_SUITE.erl

@@ -220,15 +220,15 @@ groups() ->
     ]}].
 
 init_per_suite(Config) ->
-    case py_nif:subinterp_supported() of
+    case py_nif:owngil_supported() of
         true ->
             {ok, _} = application:ensure_all_started(erlang_python),
             %% Add test directory to Python path
             PrivDir = code:priv_dir(erlang_python),
             TestDir = filename:join(filename:dirname(PrivDir), "test"),
             Config ++ [{test_dir, TestDir}];
         false ->
-            {skip, "Requires Python 3.12+"}
+            {skip, "OWN_GIL requires Python 3.14+"}
     end.
 
 end_per_suite(_Config) ->