It is possible that a program computes every possible program in parallel on a single-taped Universal Turing Machine (UTM). For example, we can order all the programs and also all the instructions of all the programs. For every instruction of a program that has to be executed, the read-write head of the UTM goes to the reserved place on the tape for that program, expands that place with one cell by replacing the rest of what has already been computed with one cell, then executes the instruction, and then goes back to the main program for deciding which instruction of which program has to be executed next and where that is. There are infinitely many programs of this type.

This is just an example, and a more precise definition of what it means for a program to be computed by another program might be appropriate here. At each time $t$, the program $p$ maps to a finite, largest non-interrupted 2-dimensional region $R_{p,t}$ of non-blank symbols. One dimension is the cellular dimension of the tape memory, the other is the temporal dimension of the computation. A program $x$ is computed by a program $y$ if, for each time $t_1$ in the computation of $x$ and for some time $t_2$ in the computation of $y$, $R_{x,t_1}$ is a part of $R_{y,t_2}$. 

The type of program in which I am interested is therefore the program for which it holds that every other program is computed by it in this way. What I wonder in the first place is whether this kind of program has a name in the literature? I know of a specific instance of this program, called FAST by Jürgen Schmidhuber (The Fastest Way of Computing All Universes. In H. Zenil, ed., A Computable Universe. World Scientific, 2012), but I would be interested in other references. I am writing a paper in which I call such a program a Universal Turing Program (UTP) for now. Would that name capture the meaning?

I am also interested in the matter whether an algorithm can decide which programs are a UTP. I believe not, because you can easily convert each possible program HON (Halt Or Not?) to a converted program CP such that:

1. CP is a UTP on the condition that HON never halts,
2. CP is not a UTP on the condition that HON halts.

CP consists of running HON plus running a UTP, plus running code that checks whether HON is still running. Just execute the next instruction of the UTP in CP as long as HON is still running. Halt CP when HON halts. If it would be possible to decide UTP-ness for each program, then we could also decide the halting problem for each HON in this way, which is known to be impossible. Is this proof correct?

Addendum: is it correct that the computation of an irrational number is a UTP?