@@ -170,28 +170,28 @@ def testSequentialEval(self):
     self._test_eval(multi_threaded=False)
 
   def _test_compile(self, multi_threaded: bool):
-    def compile_expr(n: int) -> cel.Expression:
+
+    def compile_and_eval(n: int) -> Any:
       test_case = _TEST_CASES[n % len(_TEST_CASES)]
-      return self.env.compile(test_case.expr)
+      expr = self.env.compile(test_case.expr)
+      data = test_case.data(n)
+      return expr.eval(data=data).plain_value()
 
     start_time = time.perf_counter()
     if multi_threaded:
       with concurrent.futures.ThreadPoolExecutor(max_workers=8) as executor:
-        results = list(executor.map(compile_expr, range(_NUM_COMPILATIONS)))
+        results = list(executor.map(compile_and_eval, range(_NUM_COMPILATIONS)))
     else:
-      results = [compile_expr(n) for n in range(_NUM_COMPILATIONS)]
+      results = [compile_and_eval(n) for n in range(_NUM_COMPILATIONS)]
     duration_ms = (time.perf_counter() - start_time) * 1000
 
     mode = "Multi-threaded" if multi_threaded else "Sequential"
     logging.info("%s compilation duration: %.2f ms", mode, duration_ms)
 
     self.assertLen(results, _NUM_COMPILATIONS)
-    for i, expr in enumerate(results):
+    for i, res in enumerate(results):
       test_case = _TEST_CASES[i % len(_TEST_CASES)]
-      data = test_case.data(i)
-      self.assertEqual(
-          expr.eval(data=data).plain_value(), test_case.expected(i)
-      )
+      self.assertEqual(res, test_case.expected(i))
 
   def testMultiThreadedCompilation(self):
     self._test_compile(multi_threaded=True)
 
@@ -115,8 +115,13 @@ PyCelEnvInternal::PyCelEnvInternal(
   google::protobuf::Arena arena;
   for (const cel::Config::VariableConfig& variable_config :
        env_config_.GetConfig().GetVariableConfigs()) {
-    auto status_or_type = cel::TypeInfoToType(variable_config.type_info,
-                                              descriptor_pool_.get(), &arena);
+    auto status_or_type = [&]() {
+      // Release the GIL during TypeInfoToType lookups to prevent lock order
+      // inversion with DescriptorPool's internal mutex.
+      py::gil_scoped_release gil_release;
+      return cel::TypeInfoToType(variable_config.type_info,
+                                 descriptor_pool_.get(), &arena);
+    }();
     if (status_or_type.ok()) {
       variable_types_[variable_config.name] =
           PyCelType::FromCelType(*status_or_type);
@@ -314,13 +319,6 @@ absl::StatusOr<std::unique_ptr<cel::Runtime>> PyCelEnvInternal::BuildRuntime(
       if (it == function_impls_.end()) {
         continue;
       }
-      py::object py_function;
-      if (!PyGILState_Check()) {
-        py::gil_scoped_acquire acquire;
-        py_function = it->second;
-      } else {
-        py_function = it->second;
-      }
       std::vector<cel::Kind> param_kinds;
       param_kinds.reserve(overload_config.parameters.size());
       for (const cel::Config::TypeInfo& parameter :
@@ -338,10 +336,9 @@ absl::StatusOr<std::unique_ptr<cel::Runtime>> PyCelEnvInternal::BuildRuntime(
           cel::TypeInfoToType(overload_config.return_type,
                               descriptor_pool_.get(), &arena));
       CEL_PYTHON_RETURN_IF_ERROR(builder.function_registry().Register(
-          descriptor,
-          std::make_unique<PyCelFunctionAdapter>(
-              function_config.name, PyCelType::FromCelType(return_type),
-              std::move(py_function))));
+          descriptor, std::make_unique<PyCelFunctionAdapter>(
+                          function_config.name,
+                          PyCelType::FromCelType(return_type), it->second)));
     }
   }
   return std::move(builder).Build();
 
@@ -33,6 +33,7 @@
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_format.h"
+#include "absl/synchronization/mutex.h"
 #include "checker/validation_result.h"
 #include "common/ast.h"
 #include "common/ast_proto.h"
@@ -43,7 +44,6 @@
 #include "parser/parser_interface.h"
 #include "runtime/embedder_context.h"
 #include "runtime/runtime.h"
-#include "cel_expr_python/free_threading_mutex.h"
 #include "cel_expr_python/py_cel_activation.h"
 #include "cel_expr_python/py_cel_arena.h"
 #include "cel_expr_python/py_cel_env_internal.h"
@@ -129,7 +129,8 @@ absl::StatusOr<PyCelExpression> PyCelExpression::Compile(
 }
 
 PyCelExpression::PyCelExpression(PyCelExpression&& other) noexcept {
-  FreeThreadingLockGuard lock(other.mutex_);
+  // Lock other.mutex_ to safely move the Program and expression state.
+  absl::MutexLock lock(other.mutex_);
   expr_ = std::move(other.expr_);
   env_ = std::move(other.env_);
   cel_program_ = std::move(other.cel_program_);
@@ -155,7 +156,10 @@ PyCelType PyCelExpression::GetReturnType() {
 }
 
 absl::StatusOr<const cel::Program*> PyCelExpression::GetProgram() {
-  FreeThreadingLockGuard lock(mutex_);
+  // Lock is needed in both GIL-enabled and free-threaded builds because Eval()
+  // releases the Python GIL before calling GetProgram(), allowing multiple
+  // threads to concurrently initialize cel_program_.
+  absl::MutexLock lock(mutex_);
   if (cel_program_) {
     return cel_program_.get();
   }
@@ -179,17 +183,26 @@ absl::StatusOr<const cel::Program*> PyCelExpression::GetProgram() {
 absl::StatusOr<PyCelValue> PyCelExpression::Eval(
     const PyCelActivation& activation) {
   ABSL_CHECK(PyGILState_Check());
-  CEL_PYTHON_ASSIGN_OR_RETURN(const cel::Program* program, GetProgram());
   std::shared_ptr<PyCelArena> arena = activation.GetArena();
   std::shared_ptr<PyCelEnvInternal> env = activation.GetEnv();
-  cel::EmbedderContext embedder_context = cel::EmbedderContext::From(&env);
-  cel::EvaluateOptions options;
-  options.message_factory = env->GetMessageFactory();
-  options.embedder_context = &embedder_context;
-  CEL_PYTHON_ASSIGN_OR_RETURN(
-      cel::Value result,
-      program->Evaluate(arena->GetArena(), *activation.GetActivation(),
-                        std::move(options)));
+  cel::Value result;
+  {
+    // Release the GIL before entering C++ program creation and evaluation to
+    // prevent lock inversion/deadlock with DescriptorPool's internal mutex
+    // (C++ Locks -> DescriptorPool Mutex -> Python GIL). Callbacks into Python
+    // (such as PyCelValueProvider::Provide and PyCelFunctionAdapter::Invoke)
+    // re-acquire the GIL on demand.
+    py::gil_scoped_release gil_release;
+    CEL_PYTHON_ASSIGN_OR_RETURN(const cel::Program* program, GetProgram());
+    cel::EmbedderContext embedder_context = cel::EmbedderContext::From(&env);
+    cel::EvaluateOptions options;
+    options.message_factory = env->GetMessageFactory();
+    options.embedder_context = &embedder_context;
+    CEL_PYTHON_ASSIGN_OR_RETURN(
+        result,
+        program->Evaluate(arena->GetArena(), *activation.GetActivation(),
+                          std::move(options)));
+  }
   return PyCelValue(result, arena, std::move(env));
 }
 
 
@@ -24,8 +24,8 @@
 #include "cel/expr/syntax.pb.h"
 #include "absl/base/thread_annotations.h"
 #include "absl/status/statusor.h"
+#include "absl/synchronization/mutex.h"
 #include "runtime/runtime.h"
-#include "cel_expr_python/free_threading_mutex.h"
 #include "cel_expr_python/py_cel_activation.h"
 #include "cel_expr_python/py_cel_type.h"
 #include "cel_expr_python/py_cel_value.h"
@@ -70,7 +70,13 @@ class PyCelExpression {
   std::variant<cel::expr::ParsedExpr, cel::expr::CheckedExpr>
       expr_;
   std::shared_ptr<PyCelEnvInternal> env_;
-  mutable FreeThreadingMutex mutex_;
+  // mutex_ protects lazy initialization of cel_program_ in GetProgram().
+  // Unlike FreeThreadingMutex (which compiles to a no-op in GIL builds), a real
+  // absl::Mutex is required here because Eval() releases the Python GIL before
+  // calling GetProgram(), allowing multiple threads in both GIL-enabled and
+  // free-threaded Python builds to concurrently access and initialize
+  // cel_program_.
+  mutable absl::Mutex mutex_;
   std::unique_ptr<cel::Program> cel_program_ ABSL_GUARDED_BY(mutex_);
 };
 
 
@@ -75,15 +75,33 @@ PyCelFunction::PyCelFunction(std::string function_name,
 
 PyCelFunctionAdapter::PyCelFunctionAdapter(std::string function_name,
                                            PyCelType return_type,
-                                           py::object py_function)
+                                           const py::object& py_function)
     : function_name_(std::move(function_name)),
       return_type_(std::move(return_type)),
-      py_function_(std::move(py_function)) {}
+      py_function_(py_function.ptr()) {
+  if (!PyGILState_Check()) {
+    py::gil_scoped_acquire acquire;
+    Py_XINCREF(py_function_);
+  } else {
+    Py_XINCREF(py_function_);
+  }
+}
+
+PyCelFunctionAdapter::~PyCelFunctionAdapter() {
+  if (py_function_ != nullptr) {
+    if (!PyGILState_Check()) {
+      py::gil_scoped_acquire acquire;
+      Py_XDECREF(py_function_);
+    } else {
+      Py_XDECREF(py_function_);
+    }
+  }
+}
 
 absl::StatusOr<cel::Value> PyCelFunctionAdapter::Invoke(
     absl::Span<const cel::Value> args,
     const cel::Function::InvokeContext& context) const {
-  ABSL_CHECK(PyGILState_Check());
+  py::gil_scoped_acquire acquire;
 
   std::shared_ptr<PyCelEnvInternal> env = GetEnvFromContext(context);
   CEL_PYTHON_ASSIGN_OR_RETURN(auto py_arena,
@@ -94,7 +112,7 @@ absl::StatusOr<cel::Value> PyCelFunctionAdapter::Invoke(
                     CelValueToPyObject(args[i], env, py_arena,
                                        /*plain_value=*/true));
   }
-  PyObject* result = PyObject_CallObject(py_function_.ptr(), py_args);
+  PyObject* result = PyObject_CallObject(py_function_, py_args);
   Py_DECREF(py_args);
   absl::Status status = PyErr_toStatus();
   if (!status.ok()) {
@@ -105,9 +123,8 @@ absl::StatusOr<cel::Value> PyCelFunctionAdapter::Invoke(
   absl::StatusOr<cel::Value> cel_result = PyObjectToCelValue(
       result, return_type_,
       [this]() {
-        return absl::StrFormat(
-            "Python function '%s'",
-            PyUnicode_AsUTF8(PyObject_Repr(py_function_.ptr())));
+        return absl::StrFormat("Python function '%s'",
+                               PyUnicode_AsUTF8(PyObject_Repr(py_function_)));
       },
       env, context.arena());
   Py_XDECREF(result);
 
@@ -45,7 +45,7 @@ class PyCelFunction {
   std::string function_name() const { return function_name_; }
   const std::vector<PyCelType>& parameters() const { return parameters_; }
   bool is_member() const { return is_member_; }
-  py::object impl() const { return impl_; }
+  const py::object& impl() const { return impl_; }
   const PyCelType& return_type() const { return return_type_; }
 
  private:
@@ -61,7 +61,11 @@ class PyCelFunction {
 class PyCelFunctionAdapter : public cel::Function {
  public:
   PyCelFunctionAdapter(std::string function_name, PyCelType return_type,
-                       py::object py_function);
+                       const py::object& py_function);
+  ~PyCelFunctionAdapter() override;
+
+  PyCelFunctionAdapter(const PyCelFunctionAdapter&) = delete;
+  PyCelFunctionAdapter& operator=(const PyCelFunctionAdapter&) = delete;
 
   absl::StatusOr<cel::Value> Invoke(
       absl::Span<const cel::Value> args,
@@ -70,7 +74,7 @@ class PyCelFunctionAdapter : public cel::Function {
  private:
   std::string function_name_;
   PyCelType return_type_;
-  py::object py_function_;
+  PyObject* py_function_;
 };
 
 }  // namespace cel_python
 
@@ -43,7 +43,7 @@ class PyCelOverload {
   PyCelType return_type() const { return return_type_; }
   const std::vector<PyCelType>& parameters() const { return parameters_; }
   bool is_member() const { return is_member_; }
-  py::object py_function() const { return py_function_; }
+  const py::object& py_function() const { return py_function_; }
 
   cel::Config::FunctionOverloadConfig ToFunctionOverloadConfig() const;