Independent project ideas relating to PyPy
==========================================

PyPy allows experimentation in many directions -- indeed facilitating
experimentation in language implementation was one of the main
motivations for the project.  This page is meant to collect some ideas
of experiments that the core developers have not had time to perform
yet and also do not require too much in depth knowledge to get started
with.

Feel free to suggest new ideas and discuss them in #pypy on the freenode IRC
network or the pypy-dev mailing list (see the home_ page).

-----------

.. contents::



JIT back-ends
--------------------------------

PyPy's Just-In-Time compiler relies on backends for actual code
generation.  We have so far a 32-bit Intel backend, and a CLI one. There is
Summer of Code project for 64bit (x86_64) backend, but other options
(ARM, llvm) remain open.

.. _distribution:
.. _persistence:

Extensions of the Python language
---------------------------------

+----------------------------------------------------------------------+
| :NOTE:                                                               |
|                                                                      |
|   The ideas in this paragraph are marked as "experimental".  We may  |
|   or may not be interested in helping you out.  You are warned :-)   |
|                                                                      |
+----------------------------------------------------------------------+

One of the advantages of PyPy's implementation is that the Python-level type
of an object and its implementation are completely independent.  This should
allow a much more intuitive interface to, for example, objects that are backed
by a persistent store.  The `transparent proxy`_ objects are a key step in this
direction; now all that remains is to implement the interesting bits :-)

An example project might be to implement functionality akin to the `ZODB's
Persistent class`_, without the need for the _p_changed hacks, and in pure
Python code (should be relatively easy on top of transparent proxy).

Another example would be to implement a multi-CPU extension that internally
uses several processes and uses transparent proxies to share object views.

Other ideas are to do something interesting with sandboxing_; or to
work more on the Stackless_ features (e.g. integrate it with the JIT);
or revive the logic object space, which tried to bring unification-like
features to Python.

.. _sandboxing: sandbox.html
.. _Stackless: stackless.html


Other languages
---------------

Improve one of the `existing interpreters`__, or start a new one.
Experiment with the JIT compiler generator.

.. __: http://codespeak.net/svn/pypy/lang/


Or else...
----------

...or whatever else interests you!

Feel free to mention your interest and discuss these ideas on the `pypy-dev
mailing list`_ or on the #pypy channel on irc.freenode.net.
You can also have a look around our documentation_.


.. _`efficient propagators for specialized finite domains`: http://codespeak.net/svn/pypy/extradoc/soc-2006/constraints.txt
.. _`py.test`: http://codespeak.net/py/current/doc/test.html
.. _`py.execnet`: http://codespeak.net/py/current/doc/execnet.html
.. _`object spaces`: objspace.html
.. _`code templating solution`: http://codespeak.net/svn/pypy/extradoc/soc-2006/code-templating.txt

.. _documentation: docindex.html
.. _home: index.html
.. _`pypy-dev mailing list`: http://codespeak.net/mailman/listinfo/pypy-dev
.. _`ZODB's Persistent class`: http://www.zope.org/Documentation/Books/ZDG/current/Persistence.stx
.. _`transparent proxy`: objspace-proxies.html#tproxy