pypy / pypy / doc / index.rst

Welcome to PyPy Development

The PyPy project aims at producing a flexible and fast Python implementation. The guiding idea is to translate a Python-level description of the Python language itself to lower level languages. Rumors have it that the secret goal is being faster-than-C which is nonsense, isn't it? more...

Getting into PyPy ...

Documentation for the PyPy Python Interpreter

New features of PyPy's Python Interpreter and Translation Framework:

Status of the project.

Mailing lists, bug tracker, IRC channel

Meeting PyPy developers

The PyPy developers are organizing sprints and presenting results at conferences all year round. They will be happy to meet in person with anyone interested in the project. Watch out for sprint announcements on the development mailing list.

Project Documentation

PyPy was funded by the EU for several years. See the web site of the EU project for more details.

architecture gives a complete view of PyPy's basic design.

coding guide helps you to write code for PyPy (especially also describes coding in RPython a bit).

sprint reports lists reports written at most of our sprints, from 2003 to the present.

papers, talks and related projects lists presentations and related projects as well as our published papers.

PyPy video documentation is a page linking to the videos (e.g. of talks and introductions) that are available.

Technical reports is a page that contains links to the reports that we submitted to the European Union.

development methodology describes our sprint-driven approach.

LICENSE contains licensing details (basically a straight MIT-license).

Glossary of PyPy words to help you align your inner self with the PyPy universe.

Status

PyPy can be used to run Python programs on Linux, OS/X, Windows, on top of .NET, and on top of Java. To dig into PyPy it is recommended to try out the current Mercurial default branch, which is always working or mostly working, instead of the latest release, which is 1.5.

PyPy is mainly developed on Linux and Mac OS X. Windows is supported, but platform-specific bugs tend to take longer before we notice and fix them. Linux 64-bit machines are supported (though it may also take some time before we notice and fix bugs).

PyPy's own tests summary, daily updated, run through BuildBot infrastructure. You can also find CPython's compliance tests run with compiled pypy-c executables there.

Source Code Documentation

object spaces discusses the object space interface and several implementations.

bytecode interpreter explains the basic mechanisms of the bytecode interpreter and virtual machine.

interpreter optimizations describes our various strategies for improving the performance of our interpreter, including alternative object implementations (for strings, dictionaries and lists) in the standard object space.

translation is a detailed overview of our translation process. The rtyper is the largest component of our translation process.

dynamic-language translation is a paper that describes the translation process, especially the flow object space and the annotator in detail. (This document is one of the EU reports.)

low-level encapsulation describes how our approach hides away a lot of low level details. This document is also part of the EU reports.

translation aspects describes how we weave different properties into our interpreter during the translation process. This document is also part of the EU reports.

garbage collector strategies that can be used by the virtual machines produced by the translation process.

parser contains (outdated, unfinished) documentation about the parser.

rlib describes some modules that can be used when implementing programs in RPython.

configuration documentation describes the various configuration options that allow you to customize PyPy.

CLI backend describes the details of the .NET backend.

JIT Generation in PyPy describes how we produce the Python Just-in-time Compiler from our Python interpreter.

PyPy directory cross-reference

Here is a fully referenced alphabetical two-level deep directory overview of PyPy:

Directory explanation/links
`pypy/annotation/`_ type inferencing code for RPython programs
`pypy/bin/`_ command-line scripts, mainly py.py and translatorshell.py
`pypy/config/`_ handles the numerous options for building and running PyPy
`pypy/doc/`_ text versions of PyPy developer documentation
`pypy/doc/config/`_ documentation for the numerous translation options
`pypy/doc/discussion/`_ drafts of ideas and documentation
doc/*/ other specific documentation topics or tools
`pypy/interpreter/`_ bytecode interpreter and related objects (frames, functions, modules,...)
`pypy/interpreter/pyparser/`_ interpreter-level Python source parser
`pypy/interpreter/astcompiler/`_ interpreter-level bytecode compiler, via an AST representation
`pypy/module/`_ contains mixed modules implementing core modules with both application and interpreter level code. Not all are finished and working. Use the --withmod-xxx or --allworkingmodules translation options.
`pypy/objspace/`_ object space implementations
`pypy/objspace/trace.py`_ the trace object space monitoring bytecode and space operations
`pypy/objspace/dump.py`_ the dump object space saves a large, searchable log file with all operations
`pypy/objspace/thunk.py`_ the thunk object space, providing unique object features
`pypy/objspace/flow/`_ the FlowObjSpace implementing abstract interpretation
`pypy/objspace/std/`_ the StdObjSpace implementing CPython's objects and types
`pypy/rlib/`_ a "standard library" for RPython programs
`pypy/rpython/`_ the RPython Typer
`pypy/rpython/lltypesystem/`_ the low-level type system for C-like backends
`pypy/rpython/ootypesystem/`_ the object-oriented type system for OO backends
`pypy/rpython/memory/`_ the garbage collector construction framework
`pypy/tool/`_ various utilities and hacks used from various places
`pypy/tool/algo/`_ general-purpose algorithmic and mathematic tools
`pypy/tool/pytest/`_ support code for our testing methods
`pypy/translator/`_ translation backends and support code
`pypy/translator/backendopt/`_ general optimizations that run before a backend generates code
`pypy/translator/c/`_ the GenC backend, producing C code from an RPython program (generally via the rtyper)
`pypy/translator/cli/`_ the CLI backend for .NET (Microsoft CLR or Mono)
`pypy/translator/goal/`_ our main PyPy-translation scripts live here
`pypy/translator/jvm/`_ the Java backend
`pypy/translator/stackless/`_ the Stackless Transform
`pypy/translator/tool/`_ helper tools for translation, including the Pygame graph viewer
*/test/ many directories have a test subdirectory containing test modules (see Testing in PyPy)
_cache/ holds cache files from internally translating application level to interpreterlevel code.
Tip: Filter by directory path e.g. /media app.js to search for public/media/app.js.
Tip: Use camelCasing e.g. ProjME to search for ProjectModifiedEvent.java.
Tip: Filter by extension type e.g. /repo .js to search for all .js files in the /repo directory.
Tip: Separate your search with spaces e.g. /ssh pom.xml to search for src/ssh/pom.xml.
Tip: Use ↑ and ↓ arrow keys to navigate and return to view the file.
Tip: You can also navigate files with Ctrl+j (next) and Ctrl+k (previous) and view the file with Ctrl+o.
Tip: You can also navigate files with Alt+j (next) and Alt+k (previous) and view the file with Alt+o.