pypy.org

PyPy is an alternative implementation of the Python language, not a separate language. It runs existing Python code and, according to pypy.org, PyPy 3.12 is on average about 4 times faster than CPython 3.11. It currently supports Python 3.12, 3.11, and 2.7. If you have a pure-Python workload that is too slow under standard Python, PyPy is the most direct thing to try; if your code depends heavily on C extensions that PyPy cannot handle, compatibility becomes the deciding factor.

How PyPy relates to "normal" Python

The Python you download from python.org is CPython — the reference implementation. PyPy is a different program that implements the same language. Your .py files, syntax, and standard library usage stay the same; what changes is the runtime underneath.

That distinction matters because "Python" is a language specification, and CPython and PyPy are two implementations of it. Switching usually means installing a different interpreter and running your code with it, not rewriting your code.

What makes PyPy different

Just-in-Time compilation

PyPy's headline feature is its JIT compiler. Instead of interpreting bytecode line by line the way CPython does, PyPy watches your program as it runs, finds the hot loops, and compiles those paths into machine code. This is why long-running, loop-heavy programs tend to benefit most.

The site publishes benchmark data on speed.pypy.org, with PyPy (JIT) times normalized against CPython — smaller is better.

Memory usage

PyPy's site notes that memory-hungry Python programs — those using several hundred MBs or more — may end up taking less space than under CPython. This is a secondary benefit rather than a guarantee; memory behavior depends on the workload.

Compatibility

PyPy aims to be highly compatible with existing Python code. It supports CFFI and cppyy, and can run popular libraries such as Twisted and Django. NumPy, Scikit-learn, and others can run through a C-extension compatibility layer.

Stackless mode

PyPy ships with stackless mode by default, providing micro-threads for massive concurrency — useful when you want very large numbers of lightweight concurrent tasks.

PyPy vs CPython at a glance

When PyPy is the right choice

PyPy tends to pay off when:

• Your program is pure or mostly pure Python.
• It runs long enough for the JIT to warm up and optimize hot loops.
• You are CPU-bound rather than waiting on I/O.
• Your dependencies work under PyPy or have compatible alternatives.

CPython tends to be the safer choice when:

• You rely on C extensions that PyPy's compatibility layer does not cover.
• Your program is short-lived, so JIT warm-up never pays back.
• You need the newest Python version immediately, or a version outside 3.12/3.11/2.7.
• Your bottleneck is network or disk I/O, where interpreter speed barely matters.

A concrete way to decide

Take one representative, CPU-heavy script — for example, a data-processing loop that runs for a minute or more — and run it under both interpreters, timing each. If PyPy is meaningfully faster and all your imports succeed, it is a candidate. If an import fails or a C extension misbehaves, that failure usually decides the question for you.

The PyPy site links to external documentation for installation and usage details, and to speed.pypy.org for live benchmark data you can check against your own results.

PyPy 3.12 is, on average, about 4 times faster than CPython 3.11, according to the project's own homepage. That figure comes from benchmark times normalized to CPython, where smaller is better, and is backed by live data at speed.pypy.org. The gain comes from PyPy's Just-In-Time (JIT) compiler, which compiles hot Python code to machine code at runtime. The catch: 4x is an average across benchmarks, not a promise for your program — the real speedup depends heavily on what your code does.

Where the 4x Number Comes From

PyPy's homepage states the comparison directly: "On average, PyPy 3.12 is about 4 times faster than CPython 3.11." The accompanying chart normalizes PyPy (with JIT) benchmark times against CPython, so a bar at 0.25 means PyPy ran that benchmark in a quarter of CPython's time — a 4x speedup.

Two things to keep in mind about this number:

• It is an average over a benchmark suite, not a single workload. Some benchmarks show much larger gains; others show little or none.
• It is version-specific. The claim pairs PyPy 3.12 against CPython 3.11. PyPy currently supports Python 3.12, 3.11, and 2.7, so you can match your target Python version within that range.

You can check current results yourself at speed.pypy.org, which the homepage cites as the source of its live data.

Why PyPy Is Faster: The JIT Compiler

CPython interprets bytecode line by line. PyPy adds a JIT compiler that watches your program as it runs, identifies the loops and functions that execute most often ("hot" code), and compiles those paths down to machine code.

The practical consequences:

• Long-running, loop-heavy programs benefit most. The JIT needs time to warm up and to learn which code is hot, so a script that runs for a few seconds may see little or no gain — and can even be slower during warm-up.
• Short-lived scripts benefit least. If your program exits before the JIT has profiled and compiled anything meaningful, you pay the overhead without collecting the reward.
• Memory-hungry programs may also improve. The homepage notes that programs using several hundred MB or more might end up taking less space than under CPython, though this is a separate effect from the JIT.

The Speedup Is Not Uniform

Because the 4x figure is an average, treat it as a starting hypothesis rather than a specification. A tight numerical loop with simple types is the classic best case for a JIT. Code dominated by C extensions, heavy I/O, or work already happening outside the interpreter will move much less, since the JIT only accelerates the Python-level portion.

This is why the honest answer to "how much faster?" is: measure your own workload. The official benchmark data tells you what is possible; it does not tell you what your specific program will do.

Compatibility: What You Can Run

PyPy is described as highly compatible with existing Python code, which matters because a speedup is worthless if your dependencies break. Per the homepage, PyPy:

• Supports cffi and cppyy for C/C++ integration.
• Runs popular libraries such as Twisted and Django.
• Runs NumPy, Scikit-learn, and more through a C-extension compatibility layer.
• Ships with stackless mode by default, providing micro-threads for massive concurrency.

The C-extension compatibility layer is the key detail: libraries that rely on C extensions can work, but they run through that layer rather than being JIT-compiled themselves, so their performance characteristics differ from pure-Python code.

Deciding Whether to Switch

Use these conditions to judge whether PyPy is likely to pay off for you:

A practical approach: pick your slowest, most CPU-bound code path, run it under both CPython and PyPy on the same machine, and compare. The homepage's own framing — "Python programs often run faster on PyPy" — uses "often" deliberately, because the JIT rewards some program shapes far more than others.

Where to Go Next

• Download PyPy from pypy.org to test it against your own code.
• Check live benchmark data at speed.pypy.org to see current per-benchmark results rather than the single 4x average.
• Read the documentation (linked from the homepage) for installation and compatibility details before migrating a production project.

The headline number is real and sourced, but it is a benchmark average. The only speedup that matters for your decision is the one you measure on your own workload.

PyPy is designed as a drop-in replacement for CPython, so most pure-Python code runs unchanged. It supports Python 3.12, 3.11, and 2.7, and on average PyPy 3.12 runs about 4 times faster than CPython 3.11. The main compatibility question is not your own code but your dependencies: pure-Python libraries generally work, while libraries built on C extensions depend on whether they use a supported interface.

What "compatible" means in practice

PyPy is a compliant alternative implementation of Python. That means the language semantics, standard library, and typical application code behave as they do on CPython. If your project is written in plain Python and its dependencies are also pure Python, you can generally run it on PyPy without changes.

The friction point is C extensions. CPython's native extension API is not PyPy's native interface, so PyPy provides compatibility layers rather than running CPython C extensions directly.

Supported C-extension interfaces

PyPy explicitly supports these ways of reaching native code:

• cffi — the recommended C foreign function interface, and the one PyPy's own documentation highlights.
• cppyy — for C++ integration.
• A C-extension compatibility layer — this is what lets PyPy run libraries such as NumPy and Scikit-learn, which are built on C extensions.

If a library offers a cffi or cppyy path, that is the most reliable route on PyPy. If it only ships a CPython-specific C extension, support depends on the compatibility layer and may be slower or incomplete.

Popular libraries confirmed to run

PyPy's own materials name several widely used libraries as runnable:

This list is illustrative, not exhaustive. The pattern to apply: pure-Python frameworks like Django and Twisted work directly, while scientific and numeric libraries that rely on C extensions go through the compatibility layer.

How to decide whether your project will run

1. Check your own code. If it is pure Python, it should run as-is.
2. List your dependencies. Separate pure-Python packages from those with C extensions.
3. For C-extension packages, look for cffi or cppyy support. Those are the interfaces PyPy names as supported.
4. For packages like NumPy or Scikit-learn, expect the compatibility layer to handle it, and test your actual workload rather than assuming identical behavior.
5. Run your test suite on PyPy. Compatibility is high but not identical, so your own tests are the real verification.

Where the payoff shows up

Two advantages matter when deciding:

• Speed — the Just-In-Time compiler often makes Python programs run faster. The headline figure is about 4 times faster than CPython 3.11 on average, measured by PyPy's own benchmarks.
• Memory — memory-hungry programs using several hundred MBs or more may take less space than on CPython.

There is also stackless mode, included by default, which provides micro-threads for massive concurrency.

A note from a real user

Miðeind's founder and CEO, Vilhjálmur Þorsteinsson, said in February 2022 that PyPy let the company use Python for a larger part of its toolset than CPython alone would have supported, and that its smooth integration with C/C++ through CFFI improved the tradeoff between performance and programmer productivity. That is a concrete example of the cffi path paying off in a production setting.

The short answer

Pure-Python code and pure-Python libraries run on PyPy with high compatibility. For native code, PyPy supports cffi and cppyy, and runs NumPy, Scikit-learn, and similar libraries through a C-extension compatibility layer. Twisted and Django are confirmed to run. The practical test is always your own dependency list plus your own test suite.

Go to pypy.org to download PyPy and reach its documentation. The site provides a direct download entry point, and the documentation is linked externally. PyPy currently supports Python 3.12, 3.11, and 2.7, so you can pick the version that matches your project before downloading.

Downloading PyPy

1. Open pypy.org in your browser.
2. Use the Download PyPy link on the page.
3. Choose the release that matches the Python version you need. The site states support for Python 3.12, 3.11, and 2.7.
4. Install or unpack the build for your operating system, then run your code with the PyPy interpreter instead of python.

The download is the entry point for replacing CPython in your runtime environment. After installation, invoking PyPy runs your existing Python code under PyPy's interpreter.

Finding the Documentation

The documentation is an external link from the main site. Follow the "Documentation" link on pypy.org to reach the docs, where you can look up usage instructions, compatibility notes, and feature details.

What You Get After Installing

PyPy is described as a fast, compliant alternative implementation of Python. Its documented advantages and distinct features are:

How Much Faster Is It?

On average, PyPy 3.12 is about 4 times faster than CPython 3.11, according to the site. Benchmark times are normalized to CPython, with smaller values being better, and live data is available from speed.pypy.org.

A user quoted on the site, Vilhjálmur Þorsteinsson, founder and CEO of Miðeind (Feb 2022), noted that PyPy enabled using Python for a larger part of their toolset than CPython alone would have supported, and that its smooth integration with C/C++ through CFFI helped balance performance and programmer productivity.

Practical Notes Before You Switch

• Check your Python version first. If your project depends on a version outside 3.12, 3.11, or 2.7, confirm compatibility before replacing your runtime.
• Test C extensions. Libraries like NumPy and Scikit-learn run through a c-extension compatibility layer, so verify your specific dependencies behave as expected.
• Benchmark your own workload. The "about 4 times faster" figure is an average; actual gains depend on your code. Use the live benchmark data at speed.pypy.org as a reference, then measure your own program.

PyPy is a fast, compliant alternative implementation of Python. Its main advantages over CPython are speed from a Just-in-Time (JIT) compiler, potentially lower memory usage for memory-hungry programs, built-in stackless mode for massive concurrency, and strong compatibility with existing Python code and libraries. According to the PyPy project, PyPy 3.12 is on average about 4 times faster than CPython 3.11, and it currently supports Python 3.12, 3.11, and 2.7.

Speed: JIT compilation

PyPy's headline feature is its Just-In-Time compiler. Instead of interpreting Python code line by line like CPython, PyPy compiles frequently executed code paths into machine code at runtime, so Python programs often run faster.

The project publishes live benchmark data at speed.pypy.org, where PyPy (with JIT) benchmark times are normalized to CPython — smaller is better. The site states that on average PyPy 3.12 is about 4 times faster than CPython 3.11.

This matters most for long-running, CPU-bound workloads where the JIT has time to warm up. Short scripts that start and exit quickly may see little or no benefit, since the JIT never gets a chance to optimize hot code.

Memory usage

PyPy can also reduce memory consumption. According to the project, memory-hungry Python programs — those using several hundreds of MBs or more — might end up taking less space than they do in CPython.

This is not a universal guarantee: memory behavior depends on the workload, and some programs may use more memory under PyPy. The advantage is most likely to appear in larger, allocation-heavy applications.

Stackless mode and micro-threads

PyPy comes by default with support for stackless mode, which provides micro-threads for massive concurrency. This is built in rather than requiring a separate interpreter build, so concurrency-heavy code can be written without relying on OS threads alone.

Compatibility with existing code and libraries

PyPy is described as highly compatible with existing Python code. It supports:

• cffi and cppyy for interfacing with C and C++ code
• Popular libraries such as twisted and django
• NumPy, Scikit-learn, and more via a C-extension compatibility layer

This compatibility is what lets teams adopt PyPy without rewriting their codebase. As Vilhjálmur Þorsteinsson, founder and CEO of Miðeind, put it in February 2022: PyPy "has enabled us to use Python for a larger part of our toolset than CPython alone would have supported," and its integration with C/C++ through CFFI helped balance performance and programmer productivity.

When PyPy is a good fit

To evaluate it for your own workload, download PyPy from pypy.org, run your program under it, and compare runtime and memory against CPython. The project's live benchmark data at speed.pypy.org gives a general reference, but your specific code is the deciding factor.