1. Pypy
  2. Untitled project
  3. pypy.org


pypy.org / source / features.txt

layout: page
title: Features

PyPy features

**PyPy 1.9** implements **Python 2.7.2** and runs on Intel
`x86 (IA-32)`_ and `x86_64`_ platforms, with ARM and PPC being underway.
It supports all of the core language, passing the Python test suite
(with minor modifications that were already accepted in the main python
in newer versions). It supports most of the commonly used Python
standard library modules.  For known differences with CPython, see our
`compatibility`_ page.

If you are interested in helping to move forward, see our `howtohelp`_ page.

.. _`compatibility`: compat.html
.. _`x86 (IA-32)`: http://en.wikipedia.org/wiki/IA-32
.. _`x86_64`: http://en.wikipedia.org/wiki/X86_64
.. _`howtohelp`: howtohelp.html


Our `main executable`_ comes with a Just-in-Time compiler.  It is
`really fast`_ in running most benchmarks.  `Try it out!`_

.. _`main executable`: download.html#with-a-jit-compiler
.. _`Try it out!`: download.html#with-a-jit-compiler
.. _`really fast`: http://speed.pypy.org/


PyPy's *sandboxing* is a working prototype for the idea of running untrusted
user programs. Unlike other sandboxing approaches for Python, PyPy's does not
try to limit language features considered "unsafe". Instead we replace all
calls to external libraries (C or platform) with a stub that communicates
with an external process handling the policy.

To run the sandboxed process, you need `pypy-sandbox`_.  You also need to
get the `full sources`_ (step 1 only).  Run::

   cd pypy/pypy/translator/sandbox
   pypy_interact.py path/to/pypy-sandbox

You get a fully sandboxed interpreter, in its own filesystem hierarchy
(try ``os.listdir('/')``).  For example, you would run an untrusted
script as follows::

   mkdir virtualtmp
   cp untrusted.py virtualtmp/
   pypy_interact.py --tmp=virtualtmp pypy-sandbox /tmp/untrusted.py

Note that the path ``/tmp/untrusted.py`` is a path inside the sandboxed
filesystem.  You don't have to put ``untrusted.py`` in the real ``/tmp``
directory at all.

To read more about its features, try ``pypy_interact.py --help`` or go to
`our documentation site`_.

.. _`pypy-sandbox`: download.html#sandboxed-version
.. _`full sources`: download.html#translate
.. _`our documentation site`: http://pypy.readthedocs.org/en/latest/sandbox.html


Support for Stackless_ and greenlets are now integrated in the normal
PyPy.  More detailed information is available here__.

Note that there is still an important performance hit for programs using
Stackless features.

.. _Stackless: http://www.stackless.com/
.. __: http://doc.pypy.org/en/latest/stackless.html

Other features

PyPy has many secondary features and semi-independent
projects.  We will mention here:

* **the .NET backend:** you get a version of ``pypy-net`` that runs
  natively in the .NET/CLI VM.  Of particular interest is `the cli-jit
  branch`_, in which you can make a version of ``pypy-net`` which also
  contains a high-level JIT compiler (it compiles your Python programs
  Just in Time into CLR bytecodes, which are in turn compiled natively
  by the VM).

* **the Java backend:** PyPy can run on the Java VM, but more care is
  needed to finish this project. Writing a backend for our high-level 
  JIT compiler would be excellent.  `Contact us`_!

* **Other languages:**  we also implemented other languages that makes
  use of our RPython toolchain: Prolog_ (almost complete), as
  well as Smalltalk_, JavaScript_, Io_, Scheme_ and Gameboy_.

.. _`the cli-jit branch`: https://bitbucket.org/pypy/pypy/src/cli-jit
.. _`contact us`: contact.html
.. _Prolog: https://bitbucket.org/cfbolz/pyrolog/
.. _Smalltalk: https://bitbucket.org/pypy/lang-smalltalk/
.. _JavaScript: https://bitbucket.org/pypy/lang-js/
.. _Io: https://bitbucket.org/pypy/lang-io/
.. _Scheme: https://bitbucket.org/pypy/lang-scheme/
.. _Gameboy: https://bitbucket.org/pypy/lang-gameboy/