How Cython, SPy, and Sub‑Interpreters Are Supercharging Python Performance

During PyCon 2024, several speakers presented techniques for accelerating Python, a language traditionally criticized for its runtime speed, by leveraging sub‑interpreters, permanent objects, just‑in‑time compilation, and static typing.

Compiling Python with Cython – Saksham Sharma (Tower Research Capital) showed that rewriting performance‑critical code in C or using Cython can cut execution time from 70 ns to about 14 ns for a simple addition. He demonstrated a Python function and its Cython‑generated C code.

# Code written by Saksham Sharma
def print_add(a, b):
    c = a + b
    print(c)
    return c

# Cython‑generated C code (excerpt)
PyObject *__pyx_pf_14cython_binding_print_add(...){
    ...
    __Pyx_XDECREF(__pyx_r);
    __Pyx_INCREF(__pyx_v_c);
    __pyx_r = __pyx_v_c;
    goto _pyx_L0;
    ...
}

Static typing with SPy – Antonio Cuni (Anaconda) introduced SPy, a Python subset that adds static types to achieve C/C++‑level speed while retaining Python’s ease of use. By freezing global constants and enabling JIT optimizations, SPy can compile many operations ahead of time.

Static‑linked C extensions – Loren Arthur (Meta) explained that rewriting heavy functions in C and linking them statically (instead of as shared objects) reduces import overhead, saving thousands of hours across millions of Python applications at Meta.

Immortal objects and GIL improvements – Vinícius Gubiani Ferreira discussed PEP 683, which introduces immutable reference‑counted objects to lessen GIL contention and improve memory usage, a feature slated for Python 3.12.

Sub‑interpreters and Memhive – Yury Selivanov presented the Memhive framework, which uses a pool of sub‑interpreters sharing memory but each with its own GIL. By employing structural sharing (hamt.c), it avoids copying immutable data, achieving speedups of 6× to 150 000× depending on the workload.

These advances illustrate that, while Python may never match low‑level languages for raw speed, developers can combine compilation, static typing, and clever runtime architectures to obtain substantial performance gains.