“JIT Compiler” version

These binaries include a Just-in-Time compiler. They only work on 32-bit x86 (IA-32) CPUs that have the SSE2 instruction set (most of them do, nowadays), as well as on any x86-64 machine in the 32-bit compatibility mode.

• Linux binary
• Mac OS/X binary
• Windows binary

If your CPU is really old, it may not have SSE2. In this case, you need to translate yourself with the option --jit-backend=x86-without-sse2.

If your CPU is a 64-bit machine and you want to translate a 32-bit version of PyPy yourself, here are hints.

If you want to help us with implementing the 64-bit JIT backend, contact us!

“No JIT” version

WARNING! Unless you really want to try this out, we recommend the JIT version.

This version still has a few advantages over the JIT Compiler version. Notably, for Python programs that require large amounts of memory (at least a few hundred MBs), the following version of pypy-nojit runs them by requiring generally 1.5x or 2x less memory than CPython. These binaries work on 32-bit x86 (IA-32) CPUs as well as x86-64 CPUs in the 32-bit compatibility mode.

• Linux binary
• Mac OS/X binary
• Linux 64bit binary
• Windows binary

If your CPU is a 64-bit machine and you want to translate a 32-bit version of PyPy yourself, here are hints.

If you want to help us with finishing the implementation of the native 64-bit version (there are a few known issues, like missing code in ctypes to implement calls to C functions), contact us. In general this version will more or less translate anywhere.

“Sandbox” version

A special safe version. Read the docs about sandboxing. These binaries work on 32-bit x86 (IA-32) CPUs as well as x86-64 CPUs in the 32-bit compatibility mode.

• Linux binary
• Mac OS/X binary

It is also possible to translate a version that includes both sandboxing and the JIT compiler, although as the JIT is relatively complicated, this reduce a bit the level of confidence we can put in the result.

If your CPU is a 64-bit machine and you want to translate a 32-bit version of PyPy yourself, here are hints.

The Windows and the native 64-bit versions both need testing and careful reviewing; contact us!

“Stackless” version

Provides Stackless extensions, as well as greenlets. These binaries work on 32-bit x86 (IA-32) CPUs as well as x86-64 CPUs in the 32-bit compatibility mode.

• Linux binary
• Windows binary

It is not possible right now to combine Stackless features with the JIT.

If your CPU is a 64-bit machine and you want to translate a 32-bit version of PyPy yourself, here are hints.

For the native 64-bit version, see the issues of the no jit version..

Installing

All versions are packaged in a tar.bz2 or zip file. When uncompressed, they run in-place. On Linux or Mac OS/X, they can also be installed by manually moving the files:

/usr/bin/pypy     # or pypy-nojit etc.
/usr/share/pypy-1.3/lib-python/*
/usr/share/pypy-1.3/pypy/*

You can also install it to /usr/local/bin and /usr/local/share.

Building from source

1. Get the source code. The following packages contain the source at the same revision as the above binaries (these are svn exports):

   • pypy-1.3-src.tar.bz2 (sources, Unix line endings)
   • pypy-1.3-src.zip (sources, Windows line endings)

   Or you can checkout the current trunk using Subversion (the trunk usually works and is of course more up-to-date):

   svn co http://codespeak.net/svn/pypy/trunk pypy-trunk
   

   Windows users trying the zip file are expected to use MSVC. The trunk version contains fixes to support MinGW32. More information on our dev site.

2. Enter the goal directory:

   cd pypy-trunk/pypy/translator/goal
   

3. Run the translate.py script. Here are the common combinations of options:

   python translate.py -Ojit                # get the JIT version
   python translate.py -O2                  # get the no-jit version
   python translate.py --sandbox            # get the sandbox version
   python translate.py --stackless          # get the stackless version
   python translate.py -Ojit --backend=cli  # only for branch/cli-jit
   

4. Enjoy Mandelbrot :-) It takes on the order of one hour to finish the translation, and 1.3 GB of RAM on a 32-bit system. (Do not start a translation on a machine with 1GB or less!)

$ python
Python 2.6.2 (...)
>>> import sys
>>> sys.maxint

cd Python-2.6.4
CC="gcc -m32" LDFLAGS="-L/lib32 -L/usr/lib32 \
  -L`pwd`/lib32 -Wl,-rpath,/lib32 -Wl,-rpath,/usr/lib32" \
  ./configure
make
# and then use this ./python to run translate.py