Create a Muriel-like language and implementation

Question

Muriel is a language where the only way to loop is to create a quine and execute it. Your job is to create your own language with this property and an implementation of it in a pre-existing language.

We will define a Muriel-like language like as follows:

1. It has a built-in command for executing code in its own language, similar to Muriel's @ command or python's exec.
2. It is Turing complete.
3. If you remove the built-in execution command it is no longer Turing complete.

Muriel is Muriel-like with @ as its built-in execution command. Smurf is also Muriel-like (its built-in execution command is x). Python is not Muriel-like, since it is still Turing complete if you remove exec.

Your job is to create a Muriel-like programming language, and then to provide an implementation of it in a language of your choice. Your score is the length of the implementation, which you are trying to minimize.

Notes:

1. Your built-in execution does not need to function exactly like Muriel. It is up to you how it handles termination of the child program, errors, scoping, etc...
2. The language you write the implementation can not itself be Muriel-like. (This is so that @ is not a valid entry.) It also must have existed before this post.

Answer 1

Python 3 and "The minimum TC subset of Underload but with the characters changed to 2019, reversed, and with a 0 on top", 156 129 bytes

c,n,*s=input(),0,[]
while c:
 i,*c=c;q="6">i
 if n:n+=q*int(i)-q;s[n and-1]+=i,
 elif q:n="1"<i;s+=s[-1]*(1-n),
 else:c=s.pop()+c

Try it online!

Explanations in the header, ungolfed code in the footer.

Answer 2

CJam, CFU analogue of the ():~^ subset of Underload, 12 bytes

q_"_\~\""--~

CJam already happens to be a stack-based language with an eval instruction, which makes it a good candidate for having a Muriel-like subset.

In particular, we define a subset with the following instructions:

• "...": Push a string ... to the stack. Quotes and backslashes inside the string can be escaped using backslashes. Equivalent to Underload's ().
• _: Duplicate the top stack value. Equivalent to Underload's :.
• \: Swap the top two stack values. Not strictly necessary for Turing-completeness, but we need to permit backslashes anyway. Equivalent to Underload's ~.
• ~: Execute the top stack value. Equivalent to Underload's ^.

Explanation of the code:

q            | read input
  "_\~\""-   | remove all these characters: "_\~
 _        -  | remove all characters in the resulting string from the input
           ~ | execute the result