When it comes to running Python code, there are different options to choose from. The most common is CPython, the standard Python runtime. But there’s also PyPy, an alternative that uses a special Just-In-Time (JIT) compiler to boost speed. Many developers wonder which one truly offers better performance, especially for different types of workloads.

Performance in Raw Numerical Computations

PyPy is known for its impressive speed in mathematical calculations. It uses a JIT compiler that translates Python code into machine-level instructions on the fly, making heavy computations much faster. This advantage is clear in simple numerical tasks, where CPython struggles due to its design. For example, a test involving a loop that sums numbers takes about 9 seconds on a typical Ryzen 5 3600 running Python 3.14, but only around 0.2 seconds on PyPy. The difference is stark.

However, not all workloads benefit equally from PyPy’s strengths. Tasks that involve a lot of nested functions or complex abstractions tend to see less gain. Moreover, the way Python handles integers in CPython—without primitive, machine-level integers—adds overhead, which slows down numerical work in CPython. This fundamental difference explains why PyPy generally outperforms CPython on these kinds of tasks.

Multithreading and Concurrency Challenges

One of the limitations of PyPy is its threading model. Despite its speed in single-threaded tasks, running multi-threaded code can actually slow it down. This is because PyPy still has a GIL-like lock, which prevents true parallel execution of threads. For example, using threads to run a similar numerical workload on PyPy results in a run time of about 2.1 seconds—slower than the 1.7 seconds on CPython with a no-GIL build. Switching to a process pool in PyPy helps, reducing the time to around 1.3 seconds, but it’s still not as optimized as in CPython.

This threading bottleneck means that PyPy’s JIT is best utilized when running code in a single thread. For multi-threaded scenarios, CPython’s newer options, like a build without the GIL, are gaining ground. These new versions aim to unlock true multi-threaded performance, offering significant improvements for workloads that can leverage parallelism.

Recent Developments and Future Outlook

Meanwhile, CPython itself is evolving. The latest releases have introduced a native JIT compiler, promising better performance in many areas. Early results show noticeable improvements in some workloads, although not quite matching PyPy’s speed in raw number crunching yet. Additionally, CPython is experimenting with alternative builds that eliminate the GIL, allowing fully concurrent multi-threading. This could drastically change the performance landscape in the future.

Both runtimes are actively improving, but they serve different purposes. PyPy remains the go-to for number-heavy tasks where speed is critical, thanks to its JIT compiler. On the other hand, CPython’s new features, including its native JIT and GIL-free options, are making it more competitive across a broader range of applications. Developers might choose based on their specific needs—whether they prioritize raw speed or compatibility and multi-threading.

In summary, the choice between CPython and PyPy depends on the workload. For simple numerical calculations, PyPy still leads. However, for multi-threaded programs or applications needing the latest Python features, CPython is catching up fast. As both projects continue to evolve, the best choice might shift over time, making it an exciting space for Python developers to watch.

Inspired by

• https://www.infoworld.com/article/4117428/which-python-runtime-does-jit-better-cpython-or-pypy.html

Sources

• pypy.org
• debian.net
• debian.net