Thanks to the Object Space architecture, any feature that is
based on proxying, extending, changing or otherwise controlling the
behavior of objects in a running program is easy to implement on top of PyPy.

Here is what we have implemented so far, in historical order:

Dump Object Space: dumps all operations performed on all the objects
into a large log file. For debugging your applications.

This is a feature that was tried experimentally long ago, and we
found no really good use cases. The basic functionality is still
there, but we don’t recommend using it. Some of the examples below
might not work any more (e.g. you can’t tproxy a list object any
more). The rest can be done by hacking in standard Python. If
anyone is interested in working on tproxy again, he is welcome, but
we don’t regard this as an interesting extension.

PyPy’s Transparent Proxies allow routing of operations on objects
to a callable. Application-level code can customize objects without
interfering with the type system - type(proxied_list)islist holds true
when proxied_list is a proxied built-in list - while
giving you full control on all operations that are performed on the
proxied_list.

See [D12.1] for more context, motivation and usage of transparent proxies.

Creates a transparent proxy controlled by the given controller
callable. The proxy will appear as a completely regular instance of the given
type, but all operations on it are sent to the specified controller - which
receives a ProxyOperation instance on each operation. If type
is not specified, it defaults to type(obj) if obj is specified.

A lot of tasks could be performed using transparent proxies, including,
but not limited to:

Remote versions of objects, on which we can directly perform operations
(think about transparent distribution)

Access to persistent storage such as a database (imagine an
SQL object mapper which looks like any other object).

Access to external data structures, such as other languages, as normal
objects (of course some operations could raise exceptions, but
since operations are executed at the application level, that is not a major
problem)

PyPy’s standard object space allows us to internally have multiple
implementations of a type and change the implementation at run-time, while
application-level code consistently sees the exact same type and object.
Multiple performance optimizations using these features have already been
implemented: alternative object implementations.
Transparent Proxies use this architecture to provide control back to
application-level code.