We provide pre-compiled binaries for many platforms and OSes:
the Python2.7 compatible release — PyPy2.7 v7.3.15
the Python3.9 compatible release — PyPy3.9 v7.3.15
the Python3.10 compatible release — PyPy3.10 v7.3.15
Linux x86 64 bit
compatible with CentOS7 and later.
Windows 64 bit
compatible with any windows 64-bit you might need the VC runtime library installer vcredist.x64.exe
compatible with CentOS7 and later.
Linux x86 32 bit
compatible with CentOS7 and later
built on Redhat Linux 7.2 
The binaries above include a Just-in-Time compiler. On x86-32, they only work on CPUs that have the SSE2 instruction set (most of them do, nowadays).. They also contain stackless extensions, like greenlets.
Since version 7.3, the linux x86 binaries ship with versions of OpenSSL, SQLite3, libffi, expat, and TCL/TK binary libraries linked in. This make the binaries "portable" so that they should run on any current glibc-based linux platform. The ideas were adopted from the portable-pypy package.
This solution to the portability problem means that the versions of the packaged libraries are frozen to the version shipped, so updating your system libraries will not affect this installation of PyPy. Also see the note about SSL certificates below.
For s390x, and ppc64, the binaries target a specific operating system. These binaries are dynamically linked, and thus might not be usable due to the sad story of linux binary compatibility. This means that Linux binaries are only usable on the distributions written next to them unless you're ready to hack your system by adding symlinks to the libraries it tries to open. There are better solutions:
download PyPy from your release vendor (usually an outdated version): Ubuntu (PPA), Debian, Homebrew, MacPorts, Fedora, Gentoo and Arch are known to package PyPy, with various degrees of being up-to-date. FreshPorts packages for FreeBSD.
use conda, which will also enable installing binary-compiled packages.
recompile the CFFI-based TCL/TK, OpenSSL, or sqlite3 modules, using system libraries and the scripts in
pypy/lib_pypy/pypy_tools. This solution will not solve compatibility issues with libffi, since that is baked into PyPy.
or translate your own PyPy.
While the linux binaries ship an OpenSSL library, they do not ship a
certificate store for SSL certificates. If you wish to use SSL module,
you will need a valid certificate store. You can use the certifi package
certifi.where() or install your platform
certificates which should be discovered by the
If your CPU is really, really old, it may be a x86-32 without SSE2.
There is untested support for manually translating PyPy's JIT without
--jit-backend=x86-without-sse2) but note that your machine
is probably low-spec enough that running CPython on it is a better
idea in the first place.
This is a special version of PyPy! See the Software Transactional Memory (STM) documentation.
The other versions of PyPy are:
Try the most up-to-date nightly binary builds , if the official release is too old for what you want to do.
Reverse debugger: This version enables debugging your Python programs by going forward and backward in time. See the RevDB documentation.
Old-style sandboxing: A special safe version. This is NOT the version announced in-development during 2019! Read the docs about sandboxing. This version is not supported and not actively maintained. You will likely have to fix some issues yourself, or checkout an old version, or otherwise play around on your own. We provide this documentation only for historical reasons. Please do not use in production. For reference, there are some very old, unmaintained binaries for Linux (32bit, 64bit).
All binary versions are packaged in a
zip file. When
uncompressed, they run in-place. You can uncompress them
either somewhere in your home directory or, say, in
If you want, put a symlink from somewhere like
not move or copy the executable
pypy outside the tree --- put
a symlink to it, otherwise it will not find its libraries.
Using conda is the easiest way to get binary packages with a minimum of
compilation. The tpyical
pip workflow for packages with binary extensions
requires that the package maintainers provide a wheel for PyPy, which is
sometimes too much work for the overburdened maintainers. For more information
see the installation documentation_
If you use your distribution's PyPy package we recommend you install packages into a virtualenv. If you try to build a module and the build process complains about "missing Python.h", you may need to install the pypy-dev package.
(see more build instructions)
Get the source code. The preferred way is to checkout the current trunk using git. The trunk usually works and is of course more up-to-date:
The trunk contains PyPy 2. For PyPy 3, switch to the correct branch:
Alternatively, get one of the following smaller packages for the source at the same revision as the above binaries:
Make sure you installed the dependencies. See the list here.
rpythonscript. Here are the common combinations of options (works also with
pypy; requires CPython 2.7 or PyPy 2, even to build PyPy 3):
:-)It takes on the order of half an hour to finish the translation, and about 3GB of RAM on a 32-bit system and about 5GB on 64-bit systems. (Do not start a translation on a machine with insufficient RAM! It will just swap forever. See notes below in that case.)
If you want to install this PyPy as root, please read the next section, Packaging.
It is recommended to use PyPy to do translations, instead of using CPython, because it is twice as fast. You should just start by downloading an official release of PyPy (with the JIT). If you really have to use CPython then note that we are talking about CPython 2.7 here, not CPython 3.x. (Older versions like 2.6 are out.)
On some 32-bit systems, the address space limit of 2 or 3 GB of RAM can be an issue. More generally you may be just a little bit low of RAM. First note that 2 GB is really not enough nowadays; on Windows you first need to refer to the Windows build instructions. More precisely, translation on 32-bit takes at this point 2.7 GB if PyPy is used and 2.9 GB if CPython is used. There are two workarounds:
1. use PyPy, not CPython. If you don't have any PyPy so far, not even an older version, then you need to build one first, with some parts removed. So, first translate with:
libpypy_c.sosomewhere else, and finally call it with
...pypy-c ../../rpython/bin/rpython -Ojit.
2. if even using PyPy instead of CPython is not enough, try to tweak some internal parameters. Example (slower but saves around 400MB):
You can run translations with
--source, which only builds the C source files (and prints at the end where). Then you can
cdthere and execute
make. This is another way to reduce memory usage. Note that afterwards, you have to run manually
pypy-c .../pypy/tool/build_cffi_imports.pyif you want to be able to import the cffi-based modules.
Like other JITs, PyPy doesn't work out of the box on some Linux distributions that trade full POSIX compliance for extra security features. E.g. with PAX, you have to run PyPy with
paxctl -cm. This also applies to translation (unless you use CPython to run the translation and you specify
Once PyPy is translated from source, a binary package similar to those
provided in the section Default (with a JIT Compiler) above can be
created with the
It is recommended to use package.py because custom scripts will invariably become out-of-date. If you want to write custom scripts anyway, note an easy-to-miss point: some modules are written with CFFI, and require some compilation. If you install PyPy as root without pre-compiling them, normal users will get errors:
PyPy 2.5.1 or earlier: normal users would see permission errors. Installers need to run
pypy -c "import gdbm"and other similar commands at install time; the exact list is in package.py. Users seeing a broken installation of PyPy can fix it after-the-fact if they have sudo rights, by running once e.g.
sudo pypy -c "import gdbm.
PyPy 2.6 and later: anyone would get
ImportError: no module named _gdbm_cffi. Installers need to run
pypy _gdbm_build.pyin the
lib_pypydirectory during the installation process (plus others; see the exact list in package.py). Users seeing a broken installation of PyPy can fix it after-the-fact, by running
pypy /path/to/lib_pypy/_gdbm_build.py. This command produces a file called
_gdbm_cffi.pypy-41.solocally, which is a C extension module for PyPy. You can move it at any place where modules are normally found: e.g. in your project's main directory, or in a directory that you add to the env var
Checksums for the downloads are here