====================

Features added

• Cython now uses a new export/import naming scheme for fused C functions that
  increases the resilience against seemingly compatible user code changes.
  The original names are kept for backwards compatibility.
  (Github issue :issue:7656)

• except * (PEP-654 exception groups) is implemented for Python 3.11 and later.
  (Github issue :issue:4993)

• Unpacking in comprehensions (PEP-798) is implemented for list/set/dict comprehensions.
  It is not yet available for generator expressions.
  Original patch by Morax. (Github issue :issue:7898)

• The feature set of the shared module can be selected at build time
  by listing named features to include or exclude.
  This is an experimental configuration, subject to further improvements.
  Failures to include used features will currently result in import failures.
  (Github issue :issue:7759)

• To control the generation of the shared module, the cython command gained
  a sub-command cython generate-shared pkg/modulename.c with additional options
  --only and --exclude.
  Patch by Raza Khan. (Github issue :issue:7842)

• Exception base types are inferred for the target variable of multi-exception except
  clauses and for collections of exceptions. Properties like .args and .context
  use direct C access in CPython.
  (Github issue :issue:7783)

• Annotations on global variables are now used by type inference.
  (Github issue :issue:7877)

• C property setters can now explicitly propagate exceptions, instead of always triggering
  a call to PyErr_Occurred() by returning void.
  (Github issue :issue:7791)

• Conditions in strongly predictable if-clauses or if-else expressions can be wrapped in
  cython.likely(condition) or cython.unlikely(condition) to help the C compiler
  optimise the branch. Note that Cython automatically detects raise and assert
  statements as terminators already and marks if-clauses that directly lead to them as
  unlikely(), without user interaction.
  (Github issue :issue:7667)

• The typed tuple syntax tuple[atype, ...] for homogeneous tuples is supported.
  (Github issue :issue:7798)

• The return type inference for calls to builtin methods was improved, including dict views.
  (Github issues :issue:7887, :issue:7888)

• cython.py_int (and the same for py_float, py_complex and py_bool)
  can be used to refer to Python's builtin types in a C type context, e.g. after cdef,
  where they are normally shadowed by the C types of the same name.
  (Github issue :issue:7844)

• Constant frozenset objects are deduplicated and cached at module init time
  (similar to constant tuple and slice objects).
  Original Patch by Zhenbo Li. (Github issue :issue:2741)

• Formatting C floating point values in f-strings is faster.
  Patch by Vladimir Saraikin. (Github issue :issue:7797)

• bytearray.extend(bytes) is faster.
  (Github issue :issue:7797)

• Single character in-tests on str, bytes and bytearray are optimised.
  (Github issue :issue:3888)

• assert conditions are constant-folded.
  (Github issue :issue:7797)

• Async generator objects are slightly smaller.
  (Github issue :issue:7776)

• Two more Cython modules are compiled in the binary wheels, which should improve the
  translation speed for modules with many strings.
  (Github issue :issue:7795)

• TreeFragment.parse_from_strings() now supports full modules and .pxd files.
  Patch by Itamar Turner-Trauring. (Github issue :issue:7827)

Bugs fixed

• Several issues with .close() or .throw() of Async generator asend/athrow
  objects were resolved, following fixes in CPython.
  (Github issue :issue:7777)

• The __class__ method cell misbehaved when used together with class decorators
  and passed the decorated class (and thus an arbitrary object) into super()
  instead of the class object.
  (Github issue :issue:7721)

• Declaring a __dict__ attribute in a class as public or readonly
  generated incorrect code. It is now detected as an error.
  Patch by Anthony Donlon. (Github issue :issue:7823)

• A return value from within a prange() loop could silently return the
  default value of the return type instead of the user provided value.
  (Github issue :issue:7587)

• Setting Py_LIMITED_API to a newer API version x.y than the current runtime
  (and its header files) is now detected and will explicitly fail to compile,
  rather than running into arbitrary C compile or runtime issues.
  (Github issue :issue:7185)

• A cpdef enum with negative values changed to non-negative in Python 3.15.
  It now uses a dedicated enum implementation class to allow this.
  (Github issue :issue:7185)

• Casting to an unresolved typeof() type (e.g. cython.cast(cython.typeof(x), ...)
  where the type could not be inferred) crashed the compiler instead of reporting an error.
  Patch by Vladimir Saraikin. (Github issue :issue:7683)

• cpdef fused functions generated redundant code.
  (Github issue :issue:7778)

• Automatic C++ STL conversions in different compiler directive contexts could generate
  invalid code duplications in C++ code.
  Original Patch by bjodah. (Github issue :issue:6981)

• Subscripting frozendicts with integer keys could fail in 3.3.0a1.

• When calling builtin types to create an instance, type inference could incorrectly
  assume type as the type of the result rather the concrete builtin type in 3.3.0a1.
  (Github issue :issue:7848)

• The return type of some builtin methods were not correctly inferred in chained calls in 3.3.0a1.
  (Github issue :issue:7664)

• Iterating over a container with an incorrectly declared item type could generate
  incorrect C code in 3.3.0a1.
  (Github issues :issue:7775, :issue:7889)

• NULL pointer comparisons could fail to compile with C++ in 3.3.0a1.
  Patch by Vyas Ramasubramani. (Github issue :issue:7766)

• A C helper function for mapping function arguments could be missing in 3.3.0a1.
  (Github issue :issue:7785)

• MSVC could silently truncate long C string literals (including internal ones)
  at a 64k bytes border. This is now worked around using C char arrays.
  (Github issue :issue:7824)

• The virtualenv activation inside of cygdb when it is run from a virtualenv works in more cases.
  Original patch by Pierrick Koch and Ashutosh Varma. (Github issues :issue:1961, :issue:3629)

• Some compiler directives failed to apply to Cython's build, which lead to
  unintentionally (slightly) increased wheel sizes.
  (Github issue :issue:7801)

• Includes all fixes as of Cython 3.2.9.

Other changes

• Setting the Limited API version macro Py_LIMITED_API in PyPy or GraalPython
  now enables the Limited API usage in these runtimes. This will currently fail
  due to lack of support in the runtimes, but is intended for initial testing
  and future improvements.
  (Github issue :issue:7831)

• Cython wheels now use a shared utility code module to reduce their size.
  (Github issue :issue:7865)

3.3.0a1 (2026-06-24)

====================

Features added
--------------

* Changes were made to adapt to Python 3.15 and its Limited API.
(Github issues :issue:`6405`, :issue:`7190`, :issue:`7347`, :issue:`7348`, :issue:`7358`)

* PEP-634 Pattern Matching is implemented.
(Github issue :issue:`4029`)

* Declared container item types (e.g. ``list[float]``) are now used by the type system.
(Github issue :issue:`7288`)

* Type inference was improved for builtin Python types.
(Github issues :issue:`7536`, :issue:`7644`)

* Extension types can declare themselves explicitly as sequence or mapping with
``@cython.collection_type("sequence")`` or ``@cython.collection_type("mapping")``.
This has an effect on their behaviour in pattern matching and subscripting.
(Github issue :issue:`5027`)

* Sequence types that have their ``Py_TPFLAGS_SEQUENCE`` type flag set can benefit from
faster subscripting via the sequence protocol as Cython now bypasses the mapping protocol
for them if both protocols are implemented.
(Github issue :issue:`7432`)

* Sequence types marked as ``@cython.collection_type("sequence")`` that use C integers
in the subscript special methods now implement only the sequence and not the mapping protocol.
This allows subscripting code to avoid creating Python index objects when the index
is already available as C integer.
(Github issue :issue:`7435`)

* The Py3.15 ``frozendict`` builtin type is supported and has been backported as an alias
for ``dict`` in older Python versions.
Patches to adapt existing ``dict`` optimisations were contributed by Omkar Kabde.
(Github issues :issue:`7545`, :issue:`7647`)

* The Py3.15 ``sentinel`` builtin is supported and its C-API declarations are available in
``cpython.sentinel``.

* The builtin Python types ``int``, ``float``, ``str``, ``bytes`` and ``bytearray``
are special cased in comparisons to speed them up.
(Github issues :issue:`7452`, :issue:`7474`)

* The builtin Python types ``int`` and ``float`` are special cased in ``+``, ``-`` and ``*``
operations with (compile-time) unknown Python types in order to speed them up.
The bit operations ``^``, ``|`` and ``&`` are additionally special cased for ``int``.
(Github issues :issue:`7485`, :issue:`7541`)

* ``<bool>`` casts can be used to convert C values to Python ``True`` / ``False``.
(Github issue :issue:`7513`)

* ``cdef`` property methods support setters.
(Github issue :issue:`7505`)

* The C ``restrict`` modifier can be used in declarations.
(Github issue :issue:`7617`)

* C arrays may now be declared with (``extern`` or internal) enum values as their size.
(Github issues :issue:`7401`, :issue:`7406`)

* ``prange(num_threads=0)`` automatically selects the maximum number of OpenMP threads.
(Github issue :issue:`7586`)

* ``prange()`` and ``parallel()`` sections can be used without releasing the GIL, which
helps in freethreading builds. When releasing the GIL as part of the section declaration,
re-acquiring it immediately inside is now faster, e.g. to do per-thread Python initialisations.
(Github issue :issue:`6562`)

* ``cython.pymutex`` and ``cython.pythread_type_lock`` now support a ``.locked()`` method
to check if the lock is currently held without blocking. The method works on all Python
versions using atomic reads on Python 3.13+ and a try-acquire approach on older versions.
(Github issue :issue:`7275`)

* A simpler mechanism was added for implementing C++ exception handlers in Cython code.
(Github issues :issue:`7388`, :issue:`7390`)

* Repeated memoryview slicing inside of loops now avoids redundant reference counting,
making it substantially faster.
(Github issue :issue:`5507`)

* Indexing into Cython memoryview objects from Python is faster.
(Github issue :issue:`7529`)

* Some internal call overhead in the memoryview code was removed.
(Github issue :issue:`7609`)

* Extension types use the vectorcall interface for their instantiation in many cases.
This can be configured with a new C feature macro ``CYTHON_VECTORCALL_TPNEW``.
(Github issue :issue:`7698`)

* Coroutine methods use the faster vectorcall interface.
(Github issue :issue:`7678`)

* Vectorcalls with literal keyword arguments use cached constant keyword name tuples.
(Github issue :issue:`7713`)

* List comprehensions that generate new objects avoid refcounting overhead for appending.
(Github issue :issue:`7748`)

* Method calls in older Limited API versions are slightly faster.
(Github issue :issue:`7707`)

* C arrays are substituted for sequence iteration in more cases, also inside of generators.
Ad-hoc C array storage on the stack and in closures was reworked along the way.
(Github issues :issue:`7323`, :issue:`7339`)

* Unicode string comparisons to single character literals are faster.
(Github issue :issue:`7418`)

* F-strings are a little faster in some cases.
(Github issues :issue:`7495`, :issue:`7526`)

* PyPy and GraalPython use the vectorcall protocol to enable faster Python calls in future releases.
(Github issue :issue:`7614`)

* The runtime conversion from a Python mapping to a C struct/union uses less code.
(Github issue :issue:`7343`)

* The error handling of memoryviews uses less code.
(Github issue :issue:`7525`)

* The runtime dispatch code of fused types uses less code.
(Github issue :issue:`7501`)

* More code is extracted to the shared utility code module.
(Github issues :issue:`7556`, :issue:`7570`)

* Cython compiled functions have a more efficient memory layout in the Limited API.
(Github issue :issue:`7519`)

* Module string content is now compressed with LZSS by default, which reduces the footprint of the
decompressor code compared to the 3.2.x default ``zlib``. This also avoids a runtime dependency
on the ``zlib`` module since the tiny LZSS decompressor can be embedded in the module.
(Github issue :issue:`7577`)

* The Py2 ``print`` statement is now implemented in Cython instead of C to make it
thread-safe and uses a vectorcall into Python.
(Github issue :issue:`7642`)

* Several C++ exception declarations were added to ``libcpp.exceptions``.
(Github issue :issue:`7389`)

* Missing Python type flag declarations were added to ``cpython.object``.
(Github issue :issue:`7441`)

* Declarations for ``PyType_GetSlot()`` and the corresponding type slot IDs were added
to ``cpython.type``.

* Declarations for specialised byte-conversion functions were added to ``cpython.long`` and ``cpython.float``.
Patch by Valentin Valls. (Github issue :issue:`7738`)

* Error detection when assigning to ``const`` variables was improved.
(Github issue :issue:`7359`)

* Some cases of likely misuse of ``critical_section`` now generate warnings.
(Github issue :issue:`6766`)

* Programmatic use of Cython has become easier by avoiding the need to manually set up
the error reporting.
(Github issue :issue:`7235`)

* Autoscaling in ``cymeit`` is a little faster.

* Unicode 17.0.0 is used to parse identifiers.

Bugs fixed
----------

* Generated Cython language features like properties, auto-pickle or dataclasses
now use a critical section (on the object itself) as guard for concurrent access.
(Github issue :issue:`6621`)

* The star-import implementation needlessly rejected several names in internal use.
They are now allowed and become regular Python module attributes.
(Github issue :issue:`4931`)

* Mixing function signature declarations in Python modules and their ``.pxd`` modules could fail.
(Github issues :issue:`5970`, :issue:`4388`)

* C array declarations with type and size could fail with an exception in pure Python code.
(Github issue :issue:`7372`)

* A ``const`` modifier in C++ template type arguments could be mapped incorrectly.
(Github issue :issue:`6294`)

* C++ ``typeid()`` failed to compile on more complex expressions.
(Github issue :issue:`7069`)

* Optimised Python ``int`` and ``float`` operations did not remember their result type,
leading to less optimised code in longer expressions.
(Github issues :issue:`7363`, :issue:`7502`)

* Slices as dictionary keys confused the type inference of item access.
(Github issue :issue:`7702`)

* A race condition when ``return``ing from a ``cython.parallel.parallel`` section was fixed.
(Github issue :issue:`6521`)

* Cython still used ``(type, exc, traceback)`` for saving and restoring exception state,
even though modern CPython versions only store the exception object itself internally.
This is now modernised in many places to reduce overhead.
(Github issue :issue:`7481`)

* Exceptions originating from the ``Py_UNICODE_IS*()`` character classification macros and
the corresponding ``str.is*()`` methods, which they alias, were not handled but ignored in
the Limited API.
(Github issue :issue:`7602`)

* In the Limited API, import time failures to create code objects for compiled functions,
e.g. due to future Python API changes, are no longer fatal but generate a warning.
(Github issue :issue:`5718`)

* Several internal cases where exceptions are caught and discarded now propagate the
``BaseException`` errors and only discard the expected exceptions.
(Github issue :issue:`7600`)

* Error handling was improved when setting up the table of ``cdef`` methods for extension types
and unexpected errors are propagated.
(Github issue :issue:`7613`)

* Exceptions while setting up the automatic pickle support are now propagated.
(Github issue :issue:`7613`)

* Exceptions thrown into async generators could leave the generator in an unclosed state.
(Github issue :issue:`7618`)

* In the Limited API, failures while formatting type names in exceptions are now uniformly handled.
(Github issue :issue:`7680`)

* The global module state struct now lives in an anonymous namespace in C++ mode to
allow linking multiple modules together in one shared library file.
(Github issue :issue:`7159`)

* Dict iteration generates safer code in PyPy/GraalPy/free-threading.
(Github issue :issue:`7637`)

* The floating point parsing code relied on C implementation specific "pointer compare after free" behaviour.
Patch by stratakis. (Github issue :issue:`7463`)

* When non-heap types were used as base classes of extension heap types, the heap types
were not correctly reference counted by their instances.
(Github issue :issue:`7483`)

* The ``.__signatures__`` dict of fused functions is no longer writable.
(Github issue :issue:`7386`)

* A minimal implementation of ``.__annotate__`` was added to Cython compiled functions to make
``@functools.wraps`` work in Python 3.14+.
(Github issue :issue:`7675`)

* The ``--embed-positions`` option no longer includes absolute file paths in the C code.
(Github issue :issue:`6755`)

* Error reporting on missing braces in f-strings was misleading.
(Github issue :issue:`7436`)

* ``None`` default values for function arguments declared as ``not None`` are now rejected at compile time
rather than leading to errors at runtime.
Patch by Vyas Ramasubramani. (Github issue :issue:`7762`)

* Cython did not reject code with multiple contradicting type annotations on the same variable.
(Github issue :issue:`7246`)

* Cython no longer warns if ``@profile`` or ``@linetrace`` is applied to a function
without changing the global/outer setting. This avoids annoyance when users leave
such redundant decorators in the code for occasional use.

* Cached methods of builtin types were not GC-traversed and cleaned up as part of the module state.
Patch by Maxwell Bernstein. (Github issue :issue:`7468`)

* Modules with non-ASCII names could end up with UTF-8 characters in their C code.
(Github issue :issue:`7588`)

* Several C compiler warnings related to mixed signed/unsigned C integer usage were resolved.

* Includes all fixes as of Cython 3.2.6.

Other changes
-------------

* Support for Python 3.8 has been removed.
As a side-effekt, support for StacklessPython and Pyston (last release was 3.8) was also removed.
Python 3.9 is planned to remain supported for several years due to its use in LTS Linux distributions.
(Github issue :issue:`7271`)

* The vectorcall feature macros were unified to make ``CYTHON_VECTORCALL`` the only way to
disable this feature (if need arises). Previously the option macros ``CYTHON_METH_FASTCALL``,
``CYTHON_FAST_PYCALL`` and ``CYTHON_VECTORCALL`` all controlled different aspects of the
implementation.
(Github issue :issue:`7616`)

* Coroutines no longer provide the legacy ``_is_coroutine`` property.
(Github issue :issue:`7709`)

* ``Cython/Shadow.pyi`` has been merged into ``Cython/Shadow.py``.
(Github issue :issue:`7376`)

* The documentation now uses the "Clarity" Sphinx theme.
Patch by Libor Jelínek. (Github issue :issue:`7564`)

3.2.9 (2026-07-24)

==================

Bugs fixed
----------

* Indexing into freshly created lists with an out-of-bounds index could crash.
(Github issue :issue:`7793`)

* Function arguments with default values could end up uninitialised in closures, leading to crashes.
Patch by Anthony Donlon. (Github issue :issue:`7782`)

* ``bytearray.append(None)`` could crash. The optimised code was also lacking concurrency guards.
(Github issue :issue:`7796`)

* Some rare corner cases when concatenating text strings were resolved.
(Github issue :issue:`7799`)

* Assignments of builtin string types to typedefs of `object` could erroneously be rejected.
(Github issue :issue:`7789`)

* Subscripting ``type`` failed with a ``TypeError``.
(Github issue :issue:`5563`)

* Manually disabling ``CYTHON_VECTORCALL`` in CPython could lead to invalid C code.
Patch by Florent Gallaire. (Github issue :issue:`7807`)

* Some internal Limited API version checks for Py3.12 were corrected.
(Github issue :issue:`7845`)

3.2.8 (2026-06-30)

==================

Bugs fixed
----------

* Assigning a Python 3.14+ ``.__annotate__`` function to a Cython compiled function no longer
evaluates annotations eagerly. Fixes a regression with ``@functools.wraps()`` in Cython 3.2.6.
Patch by Jelle Zijlstra. (Github issue :issue:`7767`)

* In freethreading Python, the necessary object keep-alive while executing user code in
``.__dealloc__()`` uses a safer scheme.
Patch by Yaxing Cai. (Github issue :issue:`7769`)

* The local function state used by ``sys.monitoring`` read from uninitialised memory.
(Github issue :issue:`7774`)

* The ``.ag_running`` flag attribute of async generators was always false on big-endian systems.

3.2.6 (2026-06-24)

==================

Bugs fixed
----------

* ``@functools.wraps()`` was broken in Py3.14+ for Cython compiled functions.
(Github issue :issue:`7675`)

* A double-free in the t-string code was fixed.
(Github issue :issue:`7712`)

* The ``-`` operator declarations for iterators in ``libcpp.vector`` we corrected.
Patch by Vadim Markovtsev. (Github issue :issue:`7717`)

* The shared utility code module no longer uses a temporary file path that
changed the C code on each generation.
(Github issue :issue:`7723`)

* On 32 bit platforms, cached constants are no longer made immortal during module import.
(Github issue :issue:`7744`)

Other changes
-------------

* Binary wheels are now built with ``-DNDEBUG`` to discard runtime assertions from CPython's
inline functions.

3.2.5 (2026-05-23)

==================

Bugs fixed
----------

* A compile failure was fixed when using the walrus operator inside of try-except.
(Github issue :issue:`7462`)

* Expressions with side-effects as object argument to ``isinstance()`` could get
evaluated multiple times, e.g. when they use the walrus operator.
(Github issue :issue:`7670`)

* Several problems generating the shared utility module were resolved, including
a performance regression with memory views.
(Github issues :issue:`7487`, :issue:`7497`, :issue:`7504`, :issue:`7558`)

* Some GC and refcounting issues were resolved for Cython functions in the Limited API.
(Github issue :issue:`7594`)

* Refcounting errors and error handling issues were resolved in some rare error handling cases.
(Github issues :issue:`7597`, :issue:`7599`, :issue:`7612`, :issue:`7673`)

* Using ``cython.pymutex`` in an extension type with ``cdef`` methods generated
invalid C code missing the required ``PyMutex`` declarations.
(Github issue :issue:`6995`)

* Calling ``.get_frame()`` on Cython coroutines could crash in freethreading Python.
(Github issue :issue:`7632`)

* The vectorcall protocol was not used correctly in ``.throw()`` of Cython coroutines
when raising the exception only by type (without value or traceback).
(Github issue :issue:`7677`)

* A problem with cpdef enums in the Limited API of Python 3.11+ was resolved.
(Github issue :issue:`7503`)

* Unicode predicates like ``.isdigit()`` are now allowed to fail in the Limited API.
(Github issue :issue:`7602`)

* Conditional expressions mixing Python float and int object types could accidentally
infer float as the common result type, instead of treating both independently.

* Using ``sizeof()`` in the size declarations of ``extern`` arrays failed.
(Github issue :issue:`7451`)

* Enabling profiling generated invalid C code for non-Python return tuples.
(Github issue :issue:`7580`)

* ``abs()`` on C ``long long`` values could generate invalid C code.

* When the ``CYTHON_AVOID_BORROWED_REFS`` C macro is enabled, e.g. in GraalPython,
dict iteration could fail to compile.
Patch by Michael Šimáček. (Github issue :issue:`7631`)

* A C compiler warning about unused functions was resolved.
(Github issue :issue:`7560`)

* The ``py_safe_call_once()`` C++ mutex helper function in ``libcpp.mutex``
failed to compile.
(Github issue :issue:`7585`)

* The ``cpython.array`` declarations were adapted for Python 3.15. Direct access
to the C struct of the ``array.array`` data type might require user code changes.
(Github issue :issue:`7659`)

* Spaces in file paths written to the ``depfile`` were not escaped.
Patch by Loïc Estève. (Github issue :issue:`7423`)

* Cython's cache failed to restore multi-file results.
(Github issue :issue:`7559`)

* Using Tempita from its command line failed with a name error.
(Github issue :issue:`7567`)

Other changes
-------------

* The known builtin types were updated for Py3.15.

3.2.4 (2026-01-04)

==================

Features added
--------------

* In preparation of Cython 3.3, a new decorator ``@collection_type(tname)`` can be used
to advertise an extension type as being a ``'sequence'`` or ``'mapping'``. This currently
only has the effect of setting the ``Py_TPFLAGS_SEQUENCE`` flag on the type or not, but
is provided for convenience to allow using the new decorator already in Cython 3.2 code.

* Several C++ exception declarations were added to ``libcpp.exceptions``.
(Github issue :issue:`7389`)

Bugs fixed
----------

* Pseudo-literal default values of function arguments like ``arg=str()`` could generate
invalid C code when internally converted into a real literal.
(Github issue :issue:`6192`)

* The pickle serialisation of extension types using the ``auto_pickle`` feature was
larger than necessary since 3.2.0 for types without Python object attributes.
It is now back to the state before 3.2.0 again.
(Github issue :issue:`7443`)

* Constants are now only made immortal on freethreading Python if they are not shared.
(Github issue :issue:`7439`)

* ``PyDict_SetDefaultRef()`` is now used when available to avoid temporary borrowed references.
(Github issue :issue:`7347`)

* Includes all fixes as of Cython 3.1.8.

Features added

• The C-API declarations were updated to include the new PyList_*() functions. (Github issue 7291)

• The Py_mod_gil module setting can now be changed with a C macro, overriding the freethreading_compatible directive setting. (Github issue 7404)

Bugs fixed

• t-strings lost the last element when compiled for the Limited API. (Github issue 7381)

• The array.data property of the cpython.array declarations generated a useless exception check that degraded its use in nogil code. (Github issue 7408)

• Parallel builds with the cythonize command could request more processes than allowed by the platform, thus failing the build. (Github issue 7384)

• A minor thread sanitizer issue was resolved. (Github issue 7383)

Features added

• The C-API declarations were updated to include the new PyDict_*Ref() functions. (Github issue 7291)

Bugs fixed

• Iteration over literal sequences and strings in generators generated invalid C code since 3.2.0. This was a regression due to the C array iteration optimisation in 6926, which is now disabled inside of generators. (Github issue 7342)

• Calling special methods of known exception types failed with an AttributeError. (Github issue 7342)

• Calling the unbound __mul__ special method of builtin collections with subtypes failed. (Github issue 7340)

• C string literals could generate invalid "const to non-const" casts in the C code. (Github issue 7346)

• yield is no longer allowed inside of a cython.critical_section, but is now allowed while holding a cython.pymutex. (Github issue 7317)

• Under lock congestion, acquiring the GIL could crash in Python 3.11, part 2. This bug was introduced in Cython 3.2.0. (Github issue 7312)

• The new py_safe_* functions in libc.threads triggered C compiler warnings. (Github issue 7356)

Features added

• Cython now leaves markers about its utility code dependencies in the generated C code to help debugging "unused function" C compiler warnings. (Github issue 7294)

Bugs fixed

• Relative imports could fail if the shared utility module is used. This bug was introduced in Cython 3.2.0. (Github issue 7290)

• Under lock congestion, acquiring the GIL could crash in Python 3.11. This bug was introduced in Cython 3.2.0. (Github issue 7312)

• Using the shared utility module left an unused C function in user modules with memoryviews. To make debugging this kind of issue easier, Cython now leaves "used by …" markers in the generated C files that indicate why a specific piece of utility code was included. This bug was introduced in Cython 3.2.0. (Github issue 7293)

• Code using the pre-import scope failed with an undefined name. This bug was introduced in Cython 3.2.0. (Github issue 7304)

• Includes all fixes as of Cython 3.1.7.

3.2.0 (2025-11-05)

(Complete changelog for the 3.2.0 release, including pre-releases.)

Features added

• Builtin exception types are now inferred. (Github issue :issue:6908)

• The list of known, inferred and optimised Python builtins was updated. range is now considered a type. ascii, bin, format, hex, oct were added as functions. (Github issue :issue:6931)

• The f-string syntax was extended according to PEP-701. (Github issue :issue:5452)

• t-strings are implemented according to PEP-750. The implementation backports the template classes but prefers existing backports if installed separately. (Github issue :issue:6811)

• Unknown return type annotations with -> are no longer rejected but produce warnings. This allows better integration with Python type hints that are not always usable for Cython. -> None is also allowed now. Patch by jpe. (Github issue :issue:6946)

• The runtime Python dispatch for fused functions is substantially faster. (Github issues :issue:1385, :issue:6996)

• Freelists (via cdef class decorator and for internally used types such as async) are now also used in the Limited API and with extension type specs enabled. (Github issue :issue:7151)

• Module imports now quickly check for an already imported module to speed up reimports. Patch by Lysandros Nikolaou. (Github issue :issue:7035)

• Type checks on PEP-604 union types (int | None) are optimised into separate checks. (Github issue :issue:6935)

• Assignments to the PEP-604 union type float | None allow any suitable Python number as input and convert it to a Python float automatically. (Github issue :issue:5750)

• Item type inference was improved for looping over literals. (Github issue :issue:6912)

• Looping over literal sequences and strings now uses efficient C array looping if possible. (Github issue :issue:6926)

• Releasing the GIL from an unknown lock state is more efficient. (Github issue :issue:6847)

• cython.critical_section(PyMutex) now works, as with Python objects. (Github issue :issue:6847)

• bool(c_int/float/ptr) avoid passing through Python objects. (Github issue :issue:7015)

• Variables assigned inside of prange loops can now be initialised outside of the loop. (Github issue :issue:7178)

• Unused exceptions in except clauses are detected in some more cases to avoid their normalisation. (Github issue :issue:7021)

• Mixed operations on C integers with Python ints use less code and are more streamlined for Py3.12+. (Github issue :issue:7244)

• Some object constants are now marked as immortal to speed up their reference counting in recent CPython versions. This can be configured with the CYTHON_IMMORTAL_CONSTANTS C macro. (Github issue :issue:7118)

• Further improvements were made to reduce the size of the resulting extension modules. (Github issue :issue:6983, :issue:7199, :issue:7220, :issue:7238, :issue:7255, :issue:7265)

• Several improvements were made in freethreaded Python code. (Github issues :issue:6936, :issue:6939, :issue:6949, :issue:6984, :issue:7011, :issue:7066, :issue:7114, :issue:7200)

• Several improvements were made for the Limited API. (Github issues :issue:6959, :issue:6991)

• Several improvements were made for the GraalPython support. Patch by Michael Šimáček. (Github issue :issue:7074)

• Some GIL-safe C-API wrappers were added to the libc/libcpp declarations. (Github issue :issue:6829, :issue:6993)

• String and number constants use less storage space in the module. (Github issues :issue:6971, :issue:6978, :issue:6986)

• The managed dict/weakref support in CPython 3.12+ is used for internal types to benefit from future CPython optimisations here. (Github issue :issue:6891)

• Using NaN as exception return value is supported. (Github issues :issue:6900, :issue:6903)

• Declarations for C++ condition variables were added. (Github issue :issue:6836)

• The annotated source HTML page shows alternating +/− markers to open/close lines. Patch by Kamil Monicz. (Github issue :issue:7099)

• cython --embed gained a new option --embed-modules=… to list further extension modules that will be statically linked into the generated extension module, to get them initialised on application start. (Github issue :issue:2849)

• The setup.py script of Cython now allows passing the desired Limited API version like --cython-limited-api=3.11. (Github issue :issue:7228)

• Unicode 16.0.0 is used to parse identifiers. (Github issue :issue:6836)

Bugs fixed

• Special float exception values could generate invalid C code. (Github issues :issue:6900, :issue:6903)

• References to the Python bool type could generate invalid C code. (Github issue :issue:6902)

• Using cython.pymutex in an extension type declared as public or api generated invalid C code missing the required PyMutex declarations. (Github issues :issue:6992, :issue:6995)

• Cython's type sharing across modules suffered from race conditions if multiple modules tried to initialise and share their types concurrently. This is due to an underlying CPython issue and cannot easily be worked around completely. In the common case that module dicts are plain Python dict objects, however, Cython now uses a .setdefault() equivalent for thread-safe type sharing. See https://github.com/python/cpython/issues/137422 (Github issue :issue:7076)

• Cython incorrectly called PyList_GetItemRef() in PyPy and GraalPython before Py3.13. (Github issue :issue:7269)

• Iterating over temporary memoryviews could crash Cython. (Github issue :issue:7005)

• Type casts on constants as part of numeric expressions could crash Cython. (Github issue :issue:6779)

• Long code bodies in with statements could crash Cython. (Github issue :issue:7122)

• Vectorcalls could use needless temp assignments for self. (Github issue :issue:6909)

• Indexing bytes failed to optimise in some cases. (Github issue :issue:6997)

• Optimised C integer formatting in f-strings failed to apply to typedef types. (Github issue :issue:7170)

• In auto-pickling, trying to unpickle an object that has no __dict__ from object pickle data that includes instance dict state is now an error. (Github issue :issue:7222)

• The type objects of heap types were not always correctly decrefed on deallocation. (Github issue :issue:7145)

• Pure mode type aliases like p_int or ulong leaked into some C type contexts, risking to conflict with user declarations. (Github issues :issue:6922, :issue:6339)

• Boolean (emptyness) tests on builtin containers could fail to handle (unlikely) errors. (Github issue :issue:7090)

• The return type of bytes.join() was sometimes inferred as plain object. (Github issue :issue:6987)

• Type inference could fail to understand prange() arguments. (Github issue :issue:6974)

• embedsignatures failed if lambda was used in function default arguments. (Github issue :issue:6880)

• An internal C function was not marked as static and leaked a linker symbol. (Github issue :issue:6957)

• PyType_FromModuleAndSpec was incorrectly used in Limited API code before Py3.10. (Github issue :issue:7181)

• Conversion code for memoryview dtypes from and to Python objects generated C warnings about incorrect const / non-const casting code. (Github issue :issue:7219)

• Cython's tools and frontend scripts now use python3 instead of just python in their shebang line. Patch by Matti Picus. (Github issue :issue:7053)

• Extension arguments defined for the shared code module were ignored in cythonize(). (Github issue :issue:7251)

• Failures while following package attributes in import pkg.module as … were not handled.

• Trying to instantiate internal types used by Cython is now prohibited. (Github issue :issue:7263)

• The setup.py script in the Demos/ subdirectory failed to build. (Github issue :issue:7228)

• The cygdb program failed to work with virtualenvs on Windows. Patch by Merlin. (Github issue :issue:7268)

• Includes all fixes as of Cython 3.1.6.

Other changes

• Some lesser used platforms (Windows ARM/i686, macOS x86_64, Linux i686, musllinux) now use Py3.9 abi3 binary wheels instead of Python version specific wheels. We also added an abi3 wheel for armv7l. (Github issues :issue:7227, :issue:7248, :issue:7250)

• Usages of Py_TPFLAGS_HAVE_FINALIZE were removed. The constant remains available as cimport from cpython.object for legacy reasons. (Github issue :issue:6423)

Bugs fixed

• Using cython.pymutex in an extension type declared as public or api generated invalid C code missing the required PyMutex declarations. (Github issues 6992, 6995)

• 3.2.0b2 generated incorrect pointer casts in the cimport importing code. (Github issue 7268)

• Cython's type sharing across modules suffered from race conditions if multiple modules tried to initialise and share their types concurrently. This is due to an underlying CPython issue and cannot easily be worked around completely. In the common case that module dicts are plain Python dict objects, however, Cython now uses a .setdefault() equivalent for thread-safe type sharing. See https://github.com/python/cpython/issues/137422 (Github issue 7076)

• Cython incorrectly called PyList_GetItemRef() in PyPy and GraalPython before Py3.13. (Github issue 7269)

Features added

• The code generated for importing and exporting cimports across modules uses less space. (Github issues 7255, 7265)

Bugs fixed

• Iteration over memoryviews could loop indefinitely in 3.2b1 when encountering a continue statement. (Github issue 7259)

• Extension arguments defined for the shared code module were ignored in cythonize(). (Github issue 7251)

• Failures while following package attributes in import pkg.module as … were not handled.

• Trying to instantiate internal types used by Cython is now prohibited. (Github issue 7263)

• Includes all fixes as of Cython 3.1.6.

Other changes

• The musllinux platform is now served with an abi3 Cython wheel instead of Python specific ones. (Github issue 7250)

Not released due to package metadata problems.

3.1.8 (2026-01-03)

==================

Bugs fixed
----------

* Assignment expressions used in comprehensions could look at the wrong scope,
thus using different variables and different data.
(Github issue :issue:`6547`)

* Some internal C symbols were not declared as ``static``, preventing static linking
of multiple modules.
Patch by Yury Popov. (Github issue :issue:`7310`)

* Accidentally using ``except +`` in C mode did not raise a compile error but generated
invalid C code leading to obscure error messages.
Patch by user202729. (Github issue :issue:`6560`)

Bugs fixed

• Unicode characters formatted from C integers with padding, as in f"{value:XXc}", could result in invalid Python string objects since Cython 3.1.0. Also, lone surrogates failed to format in this way. (Github issue 7298)

• Assigning nested structs from a list of structs (item by item) could crash Cython. (Github issue 7308)

• Cython incorrectly called PyList_GetItemRef() in PyPy and GraalPython before Py3.13. (Github issue 7269)

• Trying to instantiate internal types used by Cython is now prohibited. (Github issue 7263)

Bugs fixed

• Unicode characters formatted from C integers with f"{value:c}" could result in invalid Python string objects since Cython 3.1.0. (Github issue 7240)

• cythonize (program and function) now uses concurrent.futures.ProcessPoolExecutor instead of multiprocessing.Pool to fix a hang on build failures in parallel builds. A possible work-around is to disable parallel builds. Patch by Sviatoslav Sydorenko. (Github issue 7183)

3.1.5 (2025-10-19)

Bugs fixed

• Conversion from C++ strings longer than PY_SSIZE_T_MAX did not validate the length.

• Some non-Limited API code was incorrectly used in generated header files. (Github issue :issue:7157)

• Optimised unpacking of Python integers in expressions uses a slightly safer scheme. (Github issue :issue:7134)

• Empty return statements were not always reported when tracing. (Github issue :issue:7022)

• Value conversion errors when tracing C return statements no longer fail the trace but fall back to reporting None returns instead. (Github issue :issue:6503)

Features added

• Declarations for the new PyUnstable_*() refcounting C-API functions in Py3.14 were added.

Bugs fixed

• The monitoring code could crash on tracing. (Github issue 7050)

• Initialising the monitoring code could fail with a CPython exception. See https://github.com/nedbat/coveragepy/issues/1790#issuecomment-3257410149

• Optimised integer shifting triggered undefined behaviour in C. (Github issue 7089)

• Deallocating objects that inherit from external types defined in pxd files could run into an infinite loop. (Github issue 7143)

• A reference to metaclasses could be leaked on instantiation. (Github issue 7130)

• (Unlikely) error handling during empty builtin container tests was ineffective. (Github issue 7190)

• Generated *_api.h files used potentially unknown Cython configuration macros. (Github issue 7108)

• cythonize() avoids parallel compiler runs on systems using spawn() in multiprocessing. Patch by Marcel Bargull. (Github issue 3262)

• The @cython.ufunc decorator was missing in type checker stubs. Patch by jayClean. (Github issue 7109)

Bugs fixed

• Some method calls with 0 or 1 argument failed to use PyObject_VectorCallMethod().

• Walrus assignments of literal Python integers could generate invalid C code. (Github issue 6989)

• cython.pythread_type_lock (also used as fallback for cython.pymutex) could stall on heavily contended locks. (Github issue 6999)

• C string arrays (not pointers) always coerced to the Python default string type, even on explicit casts to other string types. (Github issue 7020)

• Unterminated \N{} character escapes in strings could unrail the parser. (Github issue 7056)

• An internal C function was not marked as static and leaked a linker symbol. (Github issue 6957)

• Some Unicode letters were not recognised as lexically valid name parts. (Github issue 7059)

• Compatibility with PyPy3.8 was lost by accident.

• The Linux binary wheels of 3.1.2 used SSSE3 CPU instructions which are not available on some CPUs. (Github issue 7038)

Bugs fixed

• Attribute lookups failed on the bool builtin type. (Github issue 6905)

• Type checks on or-ed union types could incorrectly return false. (Github issue 6420)

• Negative list indexing could accidentally wrap around twice in PyPy and the Limited API.

• Iterating over literal sequences with starred (unpacked) items could infer a wrong type for the loop variable and fail to assign the values. (Github issue 6924)

• Calls to C functions taking exception types failed to check for a None argument. (Github issue 6420)

• Fused functions had an incorrect __module__ attribute. (Github issue 6897)

• The type of Cython implemented functions had an incorrect __module__ attribute. (Github issue 6841)

• Errors while indexing into bytearray or str in nogil sections could crash. (Github issue 6947)

• bytearray.append() could silently accept some invalid character numbers.

• The C++11 <type_traits> header was included regardless of the C++ version. (Github issue 6896)

• PyDict_GetItemStringRef() was accidentally used in older Limited API versions. (Github issue 6914)

• abort() was used but not always available in the Limited API. (Github issue 6918)

• Some dependencies were missing from the depfile. (Github issue 6938)

• Embedded function signatures were not always separated from the existing docstring. (Github issue 6904)

• numpy.math was missing from Cython/Includes/ and could not be cimported. (Github issue 6859)

• Some tests were adapted for NumPy 2.x. (Github issue 6898)

• Some C compiler warnings were fixed. (Github issue 6870)

• Cython.Build was not officially exposing the cythonize function. (Github issue 6934)

Bugs fixed

• A reference leak in the async delegation code was fixed. (Github issues 6850, 6878)

• Conditional if-else expressions mixing Python and C (numeric) types could end up inferring an overly tight result type, thus leading to unexpected type conversions, runtime exceptions on assignment, or incorrect "temporary assignment" compile errors. (Github issue 6854)

• Some Limited API issues were resolved. (Github issue 6862)

• Large C long long values could be truncated when passed into PyPy. (Github issue 6890)

• callable() incorrectly reported False in PyPy for classes with metaclasses. Patch by Anatolii Aniskovych. (Github issue 6892)

• The signature of fused functions was no longer introspectable in Cython 3.1.0. (Github issue 6855)

• Coroutines could generate invalid C with line tracing enabled. (Github issue 6865)

• Code using complex() could generate invalid C code missing type declarations. (Github issue 6860)

• Code using e.g. list[int | None] outside of variable/argument annotations failed to compile. (Github issue 6856)

• Code using ctuples in a const context could generate invalid C. (Github issue 6864)

• Accessing special methods on cpdef enums failed to compile.

• Some C compiler warnings were resolved. Patches by Daniel Larraz. (Github issues 6876, 3172, 6873, 6877)

• Re-establish support for PyPy 3.8. (Github issue 6867)

Other changes

• No functional changes since 3.1.0 rc 2.

Bugs fixed

• Release 3.0.11 introduced some incorrect noexcept warnings. (Github issue 6335)

• Conditional assignments to variables using the walrus operator could crash. (Github issue 6094)

• Dict assignments to struct members with reserved C names could generate invalid C code.

• Fused ctuples with the same entry types but different sizes could fail to compile. (Github issue 6328)

• In Py3, pyximport was not searching sys.path when looking for importable source files. (Github issue 5615)

• Using & 0 on integers produced with int.from_bytes() could read invalid memory on Python 3.10. (Github issue 6480)

• Modules could fail to compile in PyPy 3.11 due to missing CPython specific header files. Patch by Matti Picus. (Github issue 6482)

• Minor fix in C++ partial_sum() declaration.

Features added

• The C++11 emplace* methods were added to libcpp.deque. Patch by Somin An. (Github issue 6159)

Bugs fixed

• The exception check value of functions declared in pxd files was not always applied in 3.0.10. (Github issue 6122)

• A crash on exception deallocations was fixed. (Github issue 6022)

• A crash was fixed when assigning a zero-length slice to a memoryview. Patch by Michael Man. (Github issue 6227)

• libcpp.optional.value() could crash if it raised a C++ exception. Patch by Alexander Condello. (Github issue 6190)

• The return type of str() was mishandled, leading to crashes with language_level=3. (Github issue 6166)

• bytes.startswith/endswith() failed for non-bytes substrings (e.g. bytearray). (Github issue 6168)

• Fused ctuples crashed Cython. (Github issue 6068)

• A compiler crash was fixed when using extension types in fused types. (Github issue 6204)

• The module cleanup code was incorrect for globally defined memory view slices. (Github issue 6276)

• Some adaptations were made to enable compilation in Python 3.13. (Github issues 5997, 6182, 6251)

Bugs fixed

• Cython generated incorrect self-casts when directly calling final methods of subtypes. Patch by Lisandro Dalcin. (Github issue 2747)

• Internal C names generated from C function signatures could become too long for MSVC. (Github issue 6052)

• The noexcept warnings could be misleading in some cases. Patch by Gonzalo Tornaría. (Github issue 6087)

• The @cython.ufunc implementation could generate incomplete C code. (Github issue 6064)

• The libcpp.complex declarations could result in incorrect C++ code. Patch by Raffi Enficiaud. (Github issue 6037)

• Several tests were adapted to work with both NumPy 1.x and 2.0. Patch by Matti Picus. (Github issues 6076, 6100)

• C compiler warnings when the freelist implementation is disabled (e.g. on PyPy) were fixed. It can now be disabled explicitly with the C macro guard CYTHON_USE_FREELISTS=0. (Github issue 6099)

• Some C macro guards for feature flags were missing from the NOGIL Python configuration.

• Some recently added builtins were unconditionally looked up at module import time (if used by user code) that weren't available on all Python versions and could thus fail the import.

• A performance hint regarding exported pxd declarations was improved. (Github issue 6001)

Features added

• Assigning const values to non-const variables now issues a warning. (Github issue 5639)

• Using noexcept on a function returning Python objects now issues a warning. (Github issue 5661)

• Some C-API usage was updated for the upcoming CPython 3.13. Patches by Victor Stinner et al. (Github issues 6003, 6020)

• The deprecated Py_UNICODE type is no longer used, unless required by user code. (Github issue 5982)

• std::string.replace() declarations were added to libcpp.string. Patch by Kieran Geary. (Github issue 6037)

Bugs fixed

• Cython generates incorrect (but harmless) self-casts when directly calling final methods of subtypes. Lacking a better solution, the errors that recent gcc versions produce have been silenced for the time being. Original patch by Michał Górny. (Github issue 2747)

• Unused variable warnings about clineno were fixed when C lines in tracebacks are disabled. (Github issue 6035)

• Subclass deallocation of extern classes could crash if the base class uses GC. Original patch by Jason Fried. (Github issue 5971)

• Type checks for Python memoryview could use an invalid C function. Patch by Xenia Lu. (Github issue 5988)

• Calling final fused functions could generate invalid C code. (Github issue 5989)

• Declaring extern enums multiple times could generate invalid C code. (Github issue 5905)

• pyximport used relative paths incorrectly. Patch by Stefano Rivera. (Github issue 5957)

• Running Cython with globbing characters ([]*?) in the module search path could fail. Patch by eewanco. (Github issue 5942)

• Literal strings that include braces could change the C code indentation.

Other changes

• The "enum class not importable" warning is now only issued once per enum type. (Github issue 5941)

Bugs fixed

• Using const together with defined fused types could fail to compile. (Github issue 5230)

• A "use after free" bug was fixed in parallel sections. (Github issue 5922)

• Several types were not available as cython.* types in pure Python code.

• The generated code is now correct C89 again, removing some C++ style // comments and C99-style declaration-after-code code ordering. This is still relevant for some ols C compilers, specifically ones that match old Python 2.7 installations.

Bugs fixed

• In the iterator of generator expressions, await and yield were not correctly analysed. (Github issue 5851)

• cpdef enums with the same name cimported from different modules could lead to invalid C code. (Github issue 5887)

• Some declarations in cpython.unicode were fixed and extended. (Github issue 5902)

• Compiling fused types used in pxd files could crash Cython in Python 3.11+. (Github issues 5894, 5588)

• Source files with non-ASCII file names could crash Cython. (Github issue 5873)

• Includes all bug-fixes and features from the 0.29 maintenance branch up to the 0.29.37 release.

Features added

• Fused def function dispatch is a bit faster.

• Declarations for the wchar PyUnicode API were added. (Github issue 5836)

• The Python "nogil" fork is now also detected with the new Py_GIL_DISABLED macro. Patch by Hugo van Kemenade. (Github issue 5852)

Bugs fixed

• Comparing dataclasses could give different results than Python. (Github issue 5857)

• float(std::string) generated invalid C code. (Github issue 5818)

• Using cpdef functions with cimport_from_pyx failed. (Github issue 5795)

• A crash was fixed when string-formatting a Python value fails. (Github issue 5787)

• On item access, Cython could try the sequence protocol before the mapping protocol in some cases if an object supports both. (Github issue 5776)

• A C compiler warning was resolved. (Github issue 5794)

• Complex numbers failed to compile in MSVC with C11. Patch by Lysandros Nikolaou. (Github issue 5809)

• Some issues with the Limited API and with PyPy were resolved. (Github issues 5695, 5696)

• A C++ issue in Python 3.13 was resolved. (Github issue 5790)

• Several directives are now also available (as no-ops) in Python code. (Github issue 5803)

• An error message was corrected. Patch by Mads Ynddal. (Github issue 5805)

Features added

• Preliminary support for CPython 3.13a1 was added to allow early testing. (Github issue 5767)

Bugs fixed

• A compiler crash was fixed. (Github issue 5771)

• A typo in the always_allow_keywords directive for Python code was fixed. Patch by lk-1984. (Github issue 5772)

• Some C compiler warnings were resolved. Patch by Pierre Jolivet. (Github issue 5780)

Features added

• A new compiler directive show_performance_hints was added to disable the newly added performance hint output. (Github issue 5748)

Bugs fixed

• `cythonize` required ``distutils even for operations that did not build binaries. (Github issue 5751)

• A regression in 3.0.3 was fixed that prevented calling inline functions from another inline function in .pxd files. (Github issue 5748)

• Some C compiler warnings were resolved. Patch by Pierre Jolivet. (Github issue 5756)

Features added

• More warnings were added to help users migrate and avoid bugs. (Github issue 5650)

• A warning-like category for performance hints was added that bypasses -Werror. (Github issue 5673)

• FastGIL now uses standard thread_local in C++. (Github issue 5640)

• reference_wrapper was added to libcpp.functional. Patch by Vyas Ramasubramani. (Github issue 5671)

• The cythonize command now supports the --cplus option known from the cython command. (Github issue 5736)

Bugs fixed

• Performance regressions where the GIL was needlessly acquired were fixed. (Github issues 5670, 5700)

• A reference leak for exceptions in Python 3.12 was resolved. Patch by Eric Johnson. (Github issue 5724)

• fastcall calls with keyword arguments generated incorrect C code. (Github issue 5665)

• Assigning the type converted result of a conditional (if-else) expression to int or bool variables could lead to incorrect C code. (Github issue 5731)

• Early (unlikely) failures in Python function wrappers no longer set a traceback in order to simplify the C code flow. Being mostly memory allocation errors, they probably would never have created a traceback anyway. (Github issue 5681)

• Relative cimports from packages with __init__.py files could fail. (Github issue 5715)

• Several issues with the Limited API support were resolved. (Github issues 5641, 5648, 5689)

• The code generated for special-casing both Cython functions and PyCFunctions was cleaned up to avoid calling C-API functions that were not meant for the other type respectively. This could previously trigger assertions in CPython debug builds and now also plays better with the Limited API. (Github issues 4804, 5739)

• Fix some C compiler warnings. Patches by Ralf Gommers, Oleksandr Pavlyk, Sebastian Koslowski et al. (Github issues 5651, 5663, 5668, 5717, 5726, 5734)

• Generating gdb debugging information failed when using generator expressions. Patch by Oleksandr Pavlyk. (Github issue 5552)

• Passing a setuptools.Extension into cythonize() instead of a distutils.Extension could make it miss the matching extensions.

• cython -M needlessly required distutils, which made it fail in Python 3.12. (Github issue 5681)

Other changes

• The visible deprecation warning for DEF was removed again since it proved difficult for some users to migrate away from it. The statement is still meant to be removed at some point (and thus, like IF, should not be used in new code), but the time for sunset is probably not around the corner. (Github issue 4310)

• The np_pythran option raise a DeprecationWarning if it receives other values than True and False. This will eventually be disallowed (in line with all other boolean options).

Bugs fixed

• Using None as default value for arguments annotated as int could crash Cython. (Github issue 5643)

• Default values of fused types that include complex could generate invalid C code with -DCYTHON_CCOMPLEX=0. (Github issue 5644)

• Using C++ enum class types in extension type method signatures could generate invalid C code. (Github issue 5637)

Features added

• The error messages regarding exception declarations were improved in order to give better help about possible reasons and fixes. (Github issue 5547)

Bugs fixed

• Memory view types in Python argument annotations no longer accept None. They now require an explicit Optional[] or a None default value in order to allow None to be passed. This was an oversight in the 3.0.0 release and is a BACKWARDS INCOMPATIBLE change. However, since it only applies to code using Python syntax, it probably only applies to newly written code that was written for Cython 3.0 and can easily be adapted. In most cases, we expect that this change will avoid bugs in user code rather than produce problems. (Github issue 5612)

• nogil functions using parallel code could freeze when called with the GIL held. (Github issues 5564, 5573)

• Relative cimports could end up searching globally and find the same package installed elsewhere, potentially in another version. (Github issue 5511)

• Attribute lookups on known standard library modules could accidentally search in the module namespace instead. (Github issue 5536)

• Using constructed C++ default arguments could generate invalid C++ code. (Github issue 5553)

• libcpp.memory.make_unique() was lacking C++ exception handling. (Github issue 5560)

• Some non-public and deprecated CAPI usages were replaced by public (and thus more future proof) API code.

• Many issues with the Limited API support were resolved. Patches by Lisandro Dalcin et al. (Github issues 5549, 5550, 5556, 5605, 5617)

• Some C compiler warnings were resolved. Patches by Matti Picus et al. (Github issues 5557, 5555)

• Large Python integers are now stored in hex instead of decimal strings to work around security limits in Python and generally speed up their Python object creation.

• NULL could not be used as default for fused type pointer arguments. (Github issue 5554)

• C functions that return pointer types now return NULL as default exception value. Previously, calling code wasn't aware of this and always tested for raised exceptions. (Github issue 5554)

• Untyped literal default arguments in fused functions could generate invalid C code. (Github issue 5614)

• C variables declared as const could generate invalid C code when used in closures, generator expressions, ctuples, etc. (Github issues 5558, 5333)

• Enums could not refer to previously defined enums in their definition. (Github issue 5602)

• The Python conversion code for anonymous C enums conflicted with regular int conversion. (Github issue 5623)

• Using memory views for property methods (and other special methods) could lead to refcounting problems. (Github issue 5571)

• Star-imports could generate code that tried to assign to constant C macros like PY_SSIZE_T_MAX and PY_SSIZE_T_MIN. Patch by Philipp Wagner. (Github issue 5562)

• CYTHON_USE_TYPE_SPECS can now be (explicitly) enabled in PyPy.

• The template parameter "delimeters" in the Tempita Template class was corrected to "delimiters". The old spelling is still available in the main template API but now issues a DeprecationWarning. (Github issue 5608)

• The cython --version output is now less likely to reach both stdout and stderr. Patch by Eli Schwartz. (Github issue 5504)

• The sdist was missing the Shadow.pyi stub file.

Cython 3.0.0 has been a very large effort that cleaned up many old warts, introduced many new features, and introduces a couple of intentional behaviour changes, even though the goal remained to stay compatible as much as possible with Cython 0.29.x. For details, see the migration guide.

As the development was spread out over several years, a lot of things have happened in the meantime. Many crucial bugfixes and some features were backported to 0.29.x and are not strictly speaking "new" in Cython 3.0.0.

Bugs fixed

• Fix a potential crash while cleaning up subtypes of externally imported extension types when terminating Python. This was introduced in Cython 0.29.35.

• Fix a complex related compile error on Windows. (Github issue 5512)

• Compiling fused types used in pxd files could crash Cython in Python 3.11+. (Github issues 5894, 5588)

• cythonize failed to consider the CYTHON_FORCE_REGEN env variable. Patch by Harmen Stoppels. (Github issue 5712)

Bugs fixed

• Async generators lost their return value in PyPy. (Github issue 5465)

• The outdated C macro _PyGC_FINALIZED() is no longer used in Py3.9+.

• The deprecated Py_OptimizeFlag is no longer used in Python 3.9+. (Github issue 5343)

• Using the global __debug__ variable but not assertions could lead to compile errors.

• The broken HTML template support was removed from Tempita. (Github issue 3309)

Bugs fixed

• A garbage collection enabled subtype of a non-GC extension type could call into the deallocation function of the super type with GC tracking enabled. This could lead to crashes during deallocation if GC was triggered on the type at the same time. (Github issue 5432)

• Some C compile failures and crashes in CPython 3.12 were resolved.

• except + nogil was syntactically not allowed. except +nogil (i.e. defining a C++ exception handling function called nogil) is now disallowed to prevent typos. (Github issue 5430)

• A C compile failure in PyPy 3.10 was resolved. Patch by Matti Picus. (Github issue 5408)

• Cython modules now use PEP-489 multi-phase init by default in PyPy 3.9 and later. Original patch by Matti Picus. (Github issue 5413)

• API header files generated by different Cython versions can now be included in the same C file. (Github issue 5383)

• Function signatures containing a type like tuple[()] could not be printed. Patch by Lisandro Dalcin. (Github issue 5355)

Bugs fixed

• A reference leak of the for-loop list/tuple iterable was resolved if the for-loop's else: branch executes a break for an outer loop. (Github issue 5347)

• Some C compile failures in CPython 3.12 were resolved.

• Some old usages of the deprecated Python imp module were replaced with importlib. Patch by Matúš Valo. (Github issue 5300)

• Some issues with depfile generation were resolved. Patches by Eli Schwartz. (Github issues 5279, 5291)

Features added

• The cythonize and cython commands have a new option -M / --depfile to generate .dep dependency files for the compilation unit. This can be used by external build tools to track these dependencies. The cythonize option was already available in Cython 0.29.27. Patches by Evgeni Burovski and Eli Schwartz. (Github issue 1214)

Bugs fixed

• const fused types could not be used with memory views. Patch by Thomas Vincent. (Github issue 1772)

• wstr usage was removed in Python 3.12 and later (PEP-623). (Github issue 5145)

• A type check assertion for Cython functions failed in debug Python builds. (Github issue 5031)

• Fixed various compiler warnings. Patches by Lisandro Dalcin et al. (Github issues 4948, 5086)

• Fixed error when calculating complex powers of negative numbers. (Github issue 5014)

• Corrected a small mis-formatting of exception messages on Python 2. (Github issue 5018)

• The PyUnicode_AsUTF8AndSize() C-API function was missing from the CPython declarations. (Github issue 5163)

• A performance problem in the compiler was resolved when nesting conditional expressions. (Github issue 5197)

• Test suite problems with recent NumPy and CPython versions were resolved. (Github issues 5183, 5190)

Other changes

• The undocumented, untested and apparently useless syntax from somemodule cimport class/struct/union somename was deprecated in anticipation of its removal in Cython 3. The type modifier is not needed here and a plain cimport of the name will do. (Github issue 4905)

• Properly disable generation of descriptor docstrings on PyPy since they cause crashes. It was previously disabled, but only accidentally via a typo. Patch by Matti Picus. (Github issue 5083)

• The cpow directive of Cython 3.0 is available as a no-op. (Github issue 5016)

Bugs fixed

• Revert "Using memoryview typed arguments in inner functions is now rejected as unsupported." Patch by David Woods. (Github issue 4798)

• from module import * failed in 0.29.31 when using memoryviews. Patch by David Woods. (Github issue 4927)

Features added

• A new argument --module-name was added to the cython command to provide the (one) exact target module name from the command line. Patch by Matthew Brett and h-vetinari. (Github issue 4906)

• A new keyword noexcept was added for forward compatibility with Cython 3. Patch by David Woods. (Github issue 4903)

Bugs fixed

• Use importlib.util.find_spec() instead of the deprecated importlib.find_loader() function when setting up the package path at import-time. Patch by Matti Picus. (Github issue 4764)

• Require the C compiler to support the two-arg form of va_start on Python 3.10 and higher. Patch by Thomas Caswell. (Github issue 4820)

• Make fused_type subscriptable in Shadow.py. Patch by Pfebrer. (Github issue 4842)

• Fix the incorrect code generation of the target type in bytearray loops. Patch by Kenrick Everett. (Github issue 4108)

• Atomic refcounts for memoryviews were not used on some GCC versions by accident. Patch by Sam Gross. (Github issue 4915)

• Silence some GCC -Wconversion warnings in C utility code. Patch by Lisandro Dalcin. (Github issue 4854)

• Tuple multiplication was ignored in expressions such as [*(1,) * 2]. Patch by David Woods. (Github issue 4864)

• Calling append methods on extension types could fail to find the method in some cases. Patch by David Woods. (Github issue 4828)

• Ensure that object buffers (e.g. ndarray[object, ndim=1]) containing NULL pointers are safe to use, returning None instead of the NULL pointer. Patch by Sebastian Berg. (Github issue 4859)

• Using memoryview typed arguments in inner functions is now rejected as unsupported. Patch by David Woods. (Github issue 4798)

• Compilation could fail on systems (e.g. FIPS) that block MD5 checksums at runtime. (Github issue 4909)

• Experimental adaptations for the CPython "nogil" fork was added. Note that there is no official support for this in Cython 0.x. Patch by Sam Gross. (Github issue 4912)

Bugs fixed

• The GIL handling changes in 0.29.29 introduced a regression where objects could be deallocated without holding the GIL. (Github issue 4796)

Features added

• Avoid acquiring the GIL at the end of nogil functions. This change was backported in order to avoid generating wrong C code that would trigger C compiler warnings with tracing support enabled. Backport by Oleksandr Pavlyk. (Github issue 4637)

Bugs fixed

• Function definitions in finally: clauses were not correctly generated. Patch by David Woods. (Github issue 4651)

• A case where C-API functions could be called with a live exception set was fixed. Patch by Jakub Kulík. (Github issue 4722)

• Pickles can now be exchanged again with those generated from Cython 3.0 modules. (Github issue 4680)

• Cython now correctly generates Python methods for both the provided regular and reversed special numeric methods of extension types. Patch by David Woods. (Github issue 4750)

• Calling unbound extension type methods without arguments could raise an IndexError instead of a TypeError. Patch by David Woods. (Github issue 4779)

• Calling unbound .__contains__() super class methods on some builtin base types could trigger an infinite recursion. Patch by David Woods. (Github issue 4785)

• The C union type in pure Python mode mishandled some field names. Patch by Jordan Brière. (Github issue 4727)

• Allow users to overwrite the C macro _USE_MATH_DEFINES. Patch by Yuriy Chernyshov. (Github issue 4690)

• Improved compatibility with CPython 3.10/11. Patches by Thomas Caswell, David Woods. (Github issues 4609, 4667, 4721, 4730, 4777)

• Docstrings of descriptors are now provided in PyPy 7.3.9. Patch by Matti Picus. (Github issue 4701)

Bugs fixed

• Due to backwards incompatible changes in CPython 3.11a4, the feature flags CYTHON_FAST_THREAD_STATE and CYTHON_USE_EXC_INFO_STACK are now disabled in Python 3.11 and later. They are enabled again in Cython 3.0. Patch by David Woods. (Github issue 4610)

• A C compiler warning in older PyPy versions was resolved. Patch by Matti Picus. (Github issue 4236)

Features added

• The cythonize command has a new option -M to generate .dep dependency files for the compilation unit. This can be used by external build tools to track these dependencies. Patch by Evgeni Burovski. (Github issue 1214)

Bugs fixed

• Compilation failures on PyPy were resolved. Patches by Matti Picus. (Github issues 4509, 4517)

• Calls to range() with more than three arguments did not fail. Original patch by Max Bachmann. (Github issue 4550)

• Some C compiler warnings about missing type struct initialisers in Py3.10 were resolved.

• Cython no longer warns about using OpenMP 3.0 features since they are now considered generally available.

Bugs fixed

• An incompatibility with CPython 3.11.0a3 was resolved. (Github issue 4499)

• The in operator failed on literal lists with starred expressions. Patch by Arvind Natarajan. (Github issue 3938)

• A C compiler warning in PyPy about a missing struct field initialisation was resolved.

Bugs fixed

• Several incompatibilities with CPython 3.11 were resolved. Patches by David Woods, Victor Stinner, Thomas Caswell. (Github issues 4411, 4414, 4415, 4416, 4420, 4428, 4473, 4479, 4480)

• Some C compiler warnings were resolved. Patches by Lisandro Dalcin and others. (Github issue 4439)

• C++ std::move() should only be used automatically in MSVC versions that support it. Patch by Max Bachmann. (Github issue 4191)

• The Py_hash_t type failed to accept arbitrary "index" values. (Github issue 2752)

• Avoid copying unaligned 16-bit values since some platforms require them to be aligned. Use memcpy() instead to let the C compiler decide how to do it. (Github issue 4343)

• Cython crashed on invalid truthiness tests on C++ types without operator bool. Patch by David Woods. (Github issue 4348)

• The declaration of PyUnicode_CompareWithASCIIString() in cpython.unicode was incorrect. Patch by Max Bachmann. (Github issue 4344)

Bugs fixed

• Inline functions in pxd files that used memory views could lead to invalid C code if the module that imported from them does not use memory views. Patch by David Woods. (Github issue 1415)

• Several declarations in libcpp.string were added and corrected. Patch by Janek Bevendorff. (Github issue 4268)

• Pickling unbound Cython compiled methods failed. Patch by Pierre Glaser. (Github issue 2972)

• The tracing code was adapted to work with CPython 3.10.

• The optimised in operator failed on unicode strings in Py3.9 and later that were constructed from an external wchar_t source. Also, related C compiler warnings about deprecated C-API usage were resolved. (Github issue 3925)

• Some compiler crashes were resolved. Patch by David Woods. (Github issues 4214, 2811)

• An incorrect warning about 'unused' generator expressions was removed. (GIthub issue 1699)

• The attributes gen.gi_frame and coro.cr_frame of Cython compiled generators and coroutines now return an actual frame object for introspection, instead of None. (Github issue 2306)

Bugs fixed

• Some problems with Python 3.10 were resolved. Patches by Victor Stinner and David Woods. (Github issues 4046, 4100)

• An incorrect "optimisation" was removed that allowed changes to a keyword dict to leak into keyword arguments passed into a function. Patch by Peng Weikang. (Github issue 3227)

• Multiplied str constants could end up as bytes constants with language_level=2. Patch by Alphadelta14 and David Woods. (Github issue 3951)

• PY_SSIZE_T_CLEAN does not get defined any more if it is already defined. Patch by Andrew Jones. (Github issue 4104)