A number of other research initiatives are developing these same ideas:

DCG

compilers hand-written in C generate portable IR; DCG translates the IR to real code. Requires about 350 instructions to generate one instruction. Backends for different architectures are actually generated using a special-purpose language. [DCG].

`C

an extension of C built with DCG, provides high level interface [tick-C]. Basically like Fabius for C with hand-annotation.

Similix

off-line specializer for simplified Scheme. Compilers generate Scheme. Not multistage, polyvariant specializer but monovariant BTA; only supports simple lifting, but runs fast [Similix][Similix-doc].

Schism

similar to Similix, but handles types and polyvariance. Supports filters for more control of lifting among other things. Source programs can be either ML or Scheme [Schism].

Fabius

is a compiler generator for a simplified first-order ML. The compilers produce machine code directly, thus they are very, very fast [Fabius].

Washington

a cadre at the University of Washington have been studying the performance of manual RTCG. They compare a template compiler that uses tens of instructions to generate each instruction and a simulated IR system to traditional compilation [KeEggeHe91][KeEggHe93].

Fuse

is a graph-based on-line PE for Scheme. It can compile code, but not generate compilers. Designed primarily for scientific computation [Fuse]

Synthetix

not clear what it will be, but a multi-stage compiler generation is also one of their goals. They are concentrating on operating systems and file systems in particular [Synthetix].

qua-C

an on-line specializer for Alpha machine code [YaSa]. Uses hints. A number of complications are introduced by analyzing real code, though this allows code from any language/compiler to be processed. Still work in progress.

None of the automatic systems accept a low-level IR language.

None of these systems supports multilayer evaluation.

The IR used by DCG is described in [FraHa91]. They make a big deal of the difference between their procedure call interface passing DAGs and so-called `Abstract Machines'. They confuse the nature of the data structure representing the code (it's trivial to convert my abstract machine into DAGs by replacing the environment with pointers) with using a higher-order call interface instead of a one-way stream of bytes.

So how do these systems reduce ? DCG accepts a compiler intermediate representation consisting of DAGs of primops [DCG] and C function calls. Using a lower-level language reduces the time required to assemble it into finally executable machine code. Fabius generates code directly for even lighterweight compilers [Fabius].

Systems such as [Self][Smalltalk] have used lightweight code generation in the form of feedback or lazy compilation.