Simple Reflection lets a program access its code and state and interpreter. Tower Reflection also lets it access its means of interpretation---that is, the mechanism by which a program is related to its interpreter, and thence to its interpreter's interpreter, etcetera.
We close over the interpreter when constructing the closure of the procedure, and thence the tower of interpreters starting there, making it contain the whole context in which the procedure is interpreted.
By making the language of each tower level an explicit part of that level---a new contribution to this field --- we extend reflection from being a tool for reasoning about interpretation of programs to being one for reasoning about language interpretation.
The meta-evaluator implementing a tower has two rôles: it implements finitely the infinite tower, and stands in for any number of levels.
To do this, it must absorb level shifts, by realizing new levels, and abandoning old ones, on demand.
We use a shadow map from shadowed operators in the tower to shadowing operators in the meta-evaluator.
The meta-evaluator can itself be a program executed by a tower of interpreters, starting a meta-tower---an original development.
Platypus is an implementation of a reflective tower in which data representations inside and outside the tower are identical. It has two similar implementations, in C and in Lisp.
Platypus has proved to be a practical interpreter for Lisp-like languages, and promises to be able to run at speeds comparable to non-reflective interpreted systems. The appropriateness of implementing reflective interpretation by shadowing has been demonstrated.