looks promising, except for 'macro' mode, where we need to find a way to make the overrides work. i'm too tired right now to work this out, but it seems to me it's not too hard. the only problem is the meaning of ':' depends on macro mode. in short: macro mode is not 'immediate' mode, where there is a mangling between postponed and ordinary words, but macro mode here is 'all postponed' words. this makes sense in target programming to quickly shift a definition from compiled to macro. using the POSTPONE bit, all words can be easily looked up and postponed automaticly. the only problem is how to enter and leave the compile mode... one thing i can't seem to get around, is the need for escape words in the macro mode. : and ; can't be postponed, and need to be executed... this seems to be solved by using an 8 cell semantics table, with 3 bits interpret/compile host/target postpone using the special 'postpone interpretation' == 'compilation' semantics, some things can be defined, such as postponing interpret-only target words. but, after all, the name mapping is not such a bad idea, since it is really clear what happens, due to clearly defined mapping rules and dictionary order. it's quite a hack, and the interpreter is ugly, but it does work and is easy to understand.. BUT. using the semantics table is a better approach i think, as long as it's defined properly. too bad that too much needs to be changed in the original, since it's quite hard to change this projective name mapping into something with clearly defined semantics.. ok.. [% interferes with [, these are mapped to the same thing, for macro mode.. DAMN!!! ****** what's the basic problem: the interpreter what does the interpreter do: convert names to actions, depending on mode so our basic word is: interpret ( name mode -- action ) if we can define action as 'w xt' it is possible to postpone an action ****** once we can distinguish semantics, it is necessary to be able to transform semantics: word, word_ postpone