Cython VS pypy

The approach that I favour is to use Cython. The nice thing with this approach is that your code is still written as (almost) Python, but so long as you define all required types correctly it will automatically create the C extension for you. Early versions of Cython required using Cython specific typing (Python didn't have type hints when Cython was created), but it can now use Python's type hints.

and again, everything that was released after using an older version of cython.

Just for reference,

* Nuitka[0] "is a Python compiler written in Python. It's fully compatible with Python 2.6, 2.7, 3.4, 3.5, 3.6, 3.7, 3.8, 3.9, 3.10, and 3.11."

* Pypy[1] "is a replacement for CPython" with builtin optimizations such as on the fly JIT compiles.

* Cython[2] "is an optimising static compiler for both the Python programming language and the extended Cython programming language... makes writing C extensions for Python as easy as Python itself."

* Numba[3] "is an open source JIT compiler that translates a subset of Python and NumPy code into fast machine code."

* Pyston[4] "is a performance-optimizing JIT for Python, and is drop-in compatible with ... CPython 3.8.12"

[0] https://github.com/Nuitka/Nuitka

[1] https://www.pypy.org/

[2] https://cython.org/

[3] https://numba.pydata.org/

[4] https://github.com/pyston/pyston

Profile and optimize the hotspots with cython (or whatever the cool kids are using these days... It's been a while.)

JIT essentially means generating machine code for the language on the fly, either during loading of the interpreter (method JIT), or by profiling and optimizing hotspots (tracing JIT). The language itself can be statically or dynamically typed. You could also compile a dynamic language ahead of time, for example, cython.

Cython - - embed demo

You'll note I said I was playing with RPython, not PyPy. In my case, I was playing with writing a small interpreter, and comparing the RPython toolchain with the Truffle/Graal framework.

Writing RPython code, even if one is not developing or contributing to PyPy, means writing within a subset of python 2.

> RPython ("Restricted Python") is a subset of Python 2

https://www.pypy.org/posts/2022/04/how-is-pypy-tested.html

And RPython's translator specifically uses pypy, and uses python 2 syntax:

https://github.com/pypy/pypy/blob/main/rpython/bin/rpython#L...

... so getting the RPython toolchain (even if one is intending to improve the PyPy 3+ interpreters) requires setting up a pypy 2 interpreter. Hence the question in my post.