User:ChuckEsoteric08/Interpreters

Here is Esointerpreters I made

Autopsy

Autopsy in Sreg

Firsr ever Autopsy interpreter written in another esolang! Replace "PROGRAM" with Autopsy program

!! CP_is
1+ E
>> F 0
:: exec0
>> F 1
:: exec1
>> F 2
:: exec2
>> F 3
:: exec3
:: halt
!! exec0
~~ F |E PROGRAM
>> F 0
:: movefirst
>> F 46
:: .0
>> F 59
:: ;0
:: halt
!! .0
1+ A
&& F
1+ E
1+ E
:: CP_is
!! ;0
>> A 0
:: ;00
1- A
&& F
1+ F
1+ E
1+ E
:: CP_is
!! ;00
&& F
1+ F
1+ E
1+ E
1+ E
:: CP_is
!! movefirst
&& E
:: CP_is
!! exec1
~~ F |E PROGRAM
>> F 0
:: movefirst
>> F 46
:: .1
>> F 59
:: ;1
:: halt
!! .1
1+ B
&& F
1+ F
1+ E
1+ E
:: CP_is
!! ;1
>> B 0
:: ;10
1- B
&& F
1+ F
1+ F
1+ E
1+ E
:: CP_is
!! ;10
&& F
1+ F
1+ F
1+ E
1+ E
1+ E
:: CP_is
!! exec2
~~ F |E PROGRAM
>> F 0
:: movefirst
>> F 46
:: .2
>> F 59
:: ;2
:: halt
!! .2
1+ C
&& F
1+ F
1+ F
1+ E
1+ E
:: CP_is
!! ;2
>> C 0
:: ;20
1- C
&& F
1+ F
1+ F
1+ F
1+ E
1+ E
:: CP_is
!! ;20
&& F
1+ F
1+ F
1+ E
1+ E
1+ E
:: CP_is
!! exec3
~~ F |E PROGRAM
>> F 0
:: movefirst
>> F 46
:: .3
>> F 59
:: ;3
:: halt
!! .2
1+ D
&& F
1+ F
1+ F
1+ E
1+ E
:: CP_is
!! ;3
>> D 0
:: ;30
1- D
&& F
1+ E
1+ E
:: CP_is
!! ;30
&& F
1+ E
1+ E
1+ E
:: CP_is

Bitwise Cyclic Tag

Bitwise Cyclic Tag in ABCstr

When bit is deleted it is outputed.

a=def
a
:f
f
b=gh
b
:h
h
-
g1
eg=g
gc=g
c=c
gc
d=de
-=-
eg
e0=0e
g0-g
g0
g1-g
-=-
e0
e10=10e
g1=g1
c=0c
-=-
e10
e11=11e
g1=g1
c=1c
-=-
e11
d0=d0
g1=g1
c=0c
-=-
d0
d1=d1
g1=g1
c=1c
-=-
c
d1

Bitwise Cyclic Tag in ASRL?

Initial string: $^Program@Data#

!-
::
^@=@
@#=#
-=@
!#
-=-
^0=0^
@0='
'=@
-=-
!'
@1=@
-=-
!0^
^1=1^
@1=-
-=@1
^=*
*@=*@
$0=$0
#=0#
*=^
-=-
!$0
$1=$1
#=1#
*=^
-=-
!*@
*0=0*
#=0#
*=^
-=-
!0*
*1=1*
#=1#
*=^
-=-
!0*
!@
!1^
!0#
!1#
!1*
!$1

Bitwise Cyclic Tag in CDILOI

INP CODE
INP DATA
LBL CMD
IF @DATA @Y END
DEL @CODE CMD CODE
IF @CMD 0 0
IF @CMD 1 1
IF A A CMD
LBL 0
CONC @CODE 0 CODE
DEL @DATA X DATA
IF A A CMD
LBL 1
CONC @CODE 1 CODE
DEL @DATA X DATA
IF @X 0 IS0
IF @X 1 IS1
LBL IS0
CONC 0 @DATA DATA
DEL @CODE X CODE
CONC @CODE @X CODE
IF A A CMD
LBL IS1
DEL @CODE X CODE
IF @X 0 ENQ0
IF @X 1 ENQ1
LBL ENQ0
CONC @CODE @X CODE
CONC @DATA 0 DATA
IF A A CMD
LBL ENQ1
CONC @CODE @X CODE
CONC @DATA 1 DATA
IF A A CMD
LBL END

Bitwise Cyclic Tag in Let's Rewrite String!

Initial string: $^Program@Data#

"0
"1
1?
0?
!0
@0
@1
*
$
^0=0^
^1=1^
^@=@
^@
@#=#
$=$^
^0
@0=@
@1=@
$=$
^1
@=!
@
!1=@1
!0=@0
!1
^=*
^
*0=0*
*1=1*
*@=^@
*0
#=%
%
0%=00#
1%=10#
0%
1%
0*=*0
*1
#=&
&
0&=00#
1&=10#
0&
1&
1*=*1
#
%=%
&=&
?=?
"="
0*
1*
*=^
*@
$0=$0
$1=$1
$0
#=?
?
0?=00#
1?=10#
$1
#="
"
0"=01#
1"=11#
@#

Bitwise Cyclic Tag in Queue based

Unlike the one on the page of the language it has comments and it will output every deleted 0 as ............ and 1 as .............

# label index 1: input program
~@~/[0_..][1_...][$_....]~'@~(..)(.)~'@~(...)(.)~'@~;
# label index 5: input data
~@~/[0_......][1_.......][$_........]~'@~(..)(.)~'@~(...)(.)~'@~
# label index 9: execute command
[......_............][......_.............];[.._..........][..._...........]~@
[.............._..........][..............._...........]~'
# label index 10: 0
@(..........);\;(.........)~'
# label index 11: 1
@(...........);'
# label index 12: if zero continue
@~(............)~;(.........)~'
# label index 13: if one check what next command is
@~(.............)~;[.........._..............][..........._...............]'
# label index 14: if next command is 0 enqueue 0 and continue
@~(..............)~(.........);(............);~'
# label index 14: if next command is 1 enqueue 1 and continue
@~(...............)~(.........);(.............);~'

First Bitwise Cyclic Tag interpreter in RIfP

Replace 101 in first line with initial data and 00111 in second line with BCT program.

@data=^101#
@program=@^00111#
;interpret
$data
!data ^#=# halt
!program ^0=0^ is0
!program ^1=1^ is1
!program ^#=# loop
;is0
!data ^1=^ interpet
!data ^0=^ interpet
;is1
!data ^1=^1 appendx
!data ^0=^0 interpet
;appendx
!program ^#=# findlast
!program ^0=0^ append0
!program ^1=1^ append1
;findlast
!program @=@^ appendx
;append1
!data 0#=01# interpret
!data 1#=11# intrpret
;append0
!data 0#=00# intetpret
!data 1#=10# interpret
;goback
!program @^=@ toend
;toend
!program #=^# interpret
;loop
!program @=@^ interpret

Second Bitwise Cyclic Tag intepreter in RIfP

Replace 101 with initial data and 00111 with BCT program. This version uses only one variable, proving Turing-completness even with this restriction.

@string=$^00111@101#
;interpret
!string @#=@# halt
!string ^0=0^ is0
!string ^1=1^ is1
!string ^@=@ loop
;is0
!string @1=@ interpet
!string @0=@ interpet
;is1
!string @1=@1 appendx
!string @0=@0 interpet
;appendx
!string ^@=@ findlast
!string ^0=0^ append0
!string ^1=1^ append1
;findlast
!string $=$^ appendx
;append1
!string 0#=01# interpret
!string 1#=11# intrerpret
;append0
!string 0#=00# interpret
!string 1#=10# interpret
;goback
!string $^=$ toend
;toend
!string #=^# interpret
;loop
!string $=$^ interpret

Bitwise Cyclic Tag in Sreg

Replace PROGRAM with program and DATA with data (which should be reversed)

1+ A
1+ B
!! MoveData
&& D
1+ C
~~ D |C DATA
>> D 0
:: endData
>> D 48
:: mul2
>> D 49
:: mul2add1
:: MoveData
!! mul2
&& D
1+ D
1+ D
** A D A
:: MoveData
!! mul2add1
&& D
1+ D
1+ D
** A D A
1+ A
:: MoveData
!! endData
&& C
!! Execute
&& E
1+ C
~~ D |C PROGRAM
>> D 0
:: Checkempty
>> D 48
:: exec0
>> D 49
:: exec1
:: Execute
!! exec0
!! dec0
1- A
1+ E
>> A 0
:: zero0
:: dec1
!! dec1
1- A
1+ E
>> A 0
:: zero1
:: dec0
!! zero0
&& D
1+ D
1+ D
// E D A
:: Execute
!! zero1
&& D
1+ D
1+ D
// E D A
:: Execute
1- E
&& D
1+ D
1+ D
// E D A
:: Execute
!! exec1
&& B
1+ B
!! dec01
1- A
1+ E
>> A 0
:: zero01
:: dec11
!! dec11
1- A
1+ E
>> A 0
:: zero11
:: dec01
!! zero01
^^ A E
:: Execute
!! zero11
^^ A E
&& E
!! moveAB
&& E
>> A 1
:: enqnext
!! dec0AB
1- A
1+ E
>> A 0
:: zero0AB
:: dec1AB
!! dec1AB
1- A
1+ E
>> A 0
:: zero1AB
:: dec0AB
!! zero0AB
&& D
1+ D
1+ D
// E D A
** B D B
:: moveAB
!! zero1AB
&& D
1+ D
1+ D
// E D A
** B D B
:: moveAB
1- E
&& D
1+ D
1+ D
// E D A
** B D B
1+ B
:: moveAB
!! enqnext
1+ C
~~ D |C PROGRAM
>> D 48
:: enq0
>> D 49
:: enq1
>> D 0
:: enqf
!! enq0
&& D
1+ D
1+ D
** A D A
1- C
:: moveBA
!! enq1
&& D
1+ D
1+ D
** A D A
1+ A
1- C
:: moveBA
!! enqf
^^ E C
&& C
1+ C
~~ D |C PROGRAM
>> D 48
:: enq0f
&& D
1+ D
1+ D
** A D A
1+ A
^^ E C
&& E
:: moveBA
!! enq0f
&& D
1+ D
1+ D
** A D A
^^ E C
&& E
!! moveBA
&& E
>> B 1
:: Execute
!! dec0BA
1- B
1+ E
>> B 0
:: zero0BA
:: dec1BA
!! dec1BA
1- B
1+ E
>> B 0
:: zero1BA
:: dec0BA
!! zero0BA
&& D
1+ D
1+ D
// E D B
** A D A
:: moveBA
!! zero1BA
&& D
1+ D
1+ D
// E D B
** A D A
:: moveBA
1- E
&& D
1+ D
1+ D
// E D B
** A D A
1+ A
:: moveBA

Bitwise Cyclic Tag in SSREPL

Initial string: $^Program@Data#

^@=@!6
@#=@!4
*=*!26
$=$^!26
*=*!1
^0=0^!11
@0=@!9
*=*!1
@1=@!26
*=*!1
^1=1^!26
@1=@1!1
^0=0^!16
#=0#!26
*=*!18
^1=1^!24
#=1#!26
$^=$!20
*=*!1
^0=0^!22
*=*!1
^1=1^!26
*=*!1
$=$^!26
*=*!1

Bitwise Cyclic Tag in Stack based

Unlike the interpreter on page for the language it would print deleted 0's as data0 and 1's as data1

lbl inpcode
inp a
rep a 0 inpcode0
rep a 1 inpcode1
rep a $ inpcodeend
jmp a
lbl inpcode0
push inpcode0 a
push inpcode a
jmp a
lbl inpcode1
push inpcode1 a
push inpcode a
jmp a
lbl inpcodeend
rev a
lbl inpdata
inp b
rep b 0 inpdata0
rep b 1 inpdata1
rep b $ inpdataend
jmp b
lbl inpdata0
push inpdata0 b
push inpdata b
jmp b
lbl inpdata1
push inpdata1 b
push inpdata b
jmp b
lbl inpdataend
rev b
rep b inpdata0 data0
rep b inpdata1 data1
lbl exec
rep a inpcode0 cmd0
rep a inpcode1 cmd1
jmp a
lbl cmd0
rev a
push cmd0
rev a
out b
push exec a
jmp a
lbl cmd1
rev a
push cmd1
rev a
jmp b
lbl data0
push data0 b
push exec a
jmp a
lbl data1
push data1 b
rep a cmd0 next0
rep a cmd1 next1
jmp a
lbl next0
push next0 a
rev b
push data0 b
rev b
push exec a
jmp a
lbl next1
push next1 a
rev b
push data1 b
rev b
push exec a
jmp a

brainfuck

brainfuck in ABGAD(dbfi)

 ba ba ba agc bag bag b c ba ba bag b c agc agc ba agc ba agc agc agc agc agc agc agc bag gc agc agc agc agc ba ba agc agc gc b c agc agc ba ba agc ba agc 
ba agc agc agc agc agc bag ba agc agc ba agc agc agc agc agc agc gc gc b c agc ba ba ba d gc agc agc bag bag ba bag  b ba ba c gc bag ba ba c gc gc b c gc 
bag gc c gc agc ba ba bag ba c ba bag gc agc ba b bag bag gc agc ba b c ba c gc bag bag bag b c gc c agc agc gc b bag gc agc agc agc agc agc agc agc agc 
agc ba bag gc b ba b c ba ba c ba ba c c gc gc  c gc c gc bag bag gc c ba bag bag ba c ba ba bag ba ba c agc bag gc gc c gc bag gc c gc agc ba ba b c ba 
bag ba c agc bag b ba ba c gc gc gc gc bag bag gc gc c gc bag gc c agc gc gc bag agc ba agc gc gc b bag ba b b ba agc gc gc b bag ba  agc gc bag ba ba agc 
gc gc b c c c ba bag gc agc ba b c gc c agc agc ba ba b b ba bag ba c ba ba bag ba ba c c gc gc bag ba ba agc gc bag bag gc c gc c ba bag bag gc gc c gc 
bag gc c agc bag b gc agc ba ba b bag gc gc agc ba agc agc ba b  bag gc b ba bag gc gc agc ba ba b c c c gc bag ba agc gc b c ba c ba bag ba c ba c ba bag 
ba ba c ba ba c gc gc bag ba ba agc ba ba agc ba ba c gc gc bag b ba ba ba ba ba ba ba ba c gc gc bag ba # ba ba ba ba ba ba ba c gc gc bag  ba b ba ba ba 
ba ba c gc gc bag ba d ba ba ba c gc gc bag ba agc ba c gc gc bag agc gc gc c gc c e

(binary) brainfuck in CDILOI

// Binary BF interpreter
// + and - will flip bit
// . and will output current cell in binary
// , would input 0 or 1
// tape infinite in both directions
INP RCODE
CONC @RDATA 0! RDATA
CONC @LDATA 0! LDATA
CONC ! @NEST NEST
LBL CMD
IF @RCODE @A HALT
DEL @RCODE CMD RCODE
CONC @CMD @LCODE LCODE
IF @CMD + FLIP
IF @CMD - FLIP
IF @CMD > RIGHT
IF @CMD < LEFT
IF @CMD . OUT
IF @CMD , INP
IF @CMD [ SLOOP
IF @CMD ] ELOOP
IF A A CMD
LBL FLIP
DEL @RDATA BIT RDATA
IF @BIT 0 SET1
IF @BIT 1 SET0
LBL SET1
CONC 1 @RDATA RDATA
IF A A CMD
LBL SET0
CONC 0 @RDATA RDATA
IF A A CMD
LBL RIGHT
DEL @RDATA BIT RDATA
CONC @BIT @LDATA LDATA
IF @RDATA ! NEWR
IF A A CMD
LBL NEWR
CONC 0 @RDATA RDATA
IF A A CMD
LBL LEFT
DEL @LDATA BIT LDATA
CONC @BIT @RDATA RDATA
IF @LDATA ! NEWL
IF A A CMD
LBL NEWL
CONC 0 @LDATA LDATA
IF A A CMD
LBL OUT
DEL @RDATA BIT RDATA
CONC @BIT @RDATA RDATA
OUT @BIT
IF A A CMD
LBL INP
DEL @RDATA BIT RDATA
INP BIT
CONC @BIT @RDATA RDATA
IF A A CMD
LBL SLOOP
DEL @RDATA BIT RDATA
CONC @BIT @RDATA RDATA
IF @BIT 0 FIND]
IF A A CMD
LBL FIND]
DEL @RCODE CMD RCODE
CONC @CMD @LCODE LCODE
IF @CMD [ INCNEST1
IF @CMD ] DECNEST1
IF A A CMD
LBL INCNEST1
CONC * @NEST NEST
IF A A FIND]
LBL DECNEST1
IF @NEST ! CMD
DEL @NEST CMD NEST
IF A A FIND]
LBL ELOOP
DEL @RDATA BIT RDATA
CONC @BIT @RDATA RDATA
IF @BIT 1 FIND[
IF A A CMD
LBL FIND[
DEL @LCODE CMD LCODE
CONC @CMD @RCODE RCODE
IF @CMD [ INCNEST2
IF @CMD ] DECNEST2
IF A A CMD
LBL INCNEST2
CONC * @NEST NEST
IF A A FIND[
LBL DECNEST2
IF @NEST ! CMD
DEL @NEST CMD NEST
IF A A FIND[
LBL HALT

brainfuck in Duck

It has 9 cells which can have value from 0 to 9. You can change number of cells by adding or removing zeroes between [ and ] on the 2nd line

#initialise memory#
[000000000]
#input code#
?
#Execute command#
!c<^"+"@+""-"@-"","@,""."@."">"@>""<"@<""["@[""]"@]""!"@!"@c
#+#
!+~<v'1+~@c
#-#
!-~<v'1-~@c
#,#
!,~&;v~@c
#.#
!.~<v=~@c
#>#
!>~<^~@c
#<#
!<~>v~@c
#[#
![~<v~{0|0$
#inc depth by 1#
\[\1+\
#dec depth by 1#
\]\/0/1-/\
$0$]$@c|@c}
#]#
!]~<v~(0|0$
#inc depth by 1#
\]\1+\
#dec depth by 1#
\[\/0/1-/\
$0$]$@c|@c)
#end program#
!!

brainfuck in llec

+0
+0
/input
+0
'*0
?*0=33
\input
/iptofirst
-0
?0=2
\iptofirst
"1+0
+1
+1
/interpret
+0
?*0=0
\notend
\end
?*0=43
\not+
\+
/not+
?*0=44
\not,
\,
/not,
?*0=45
\not-
\-
/not-
?*0=46
\not.
\.
/not.
?*0=60
\not<
\<
/not<
?*0=63
\not>
\>
/not>
?*0=91
\not[
\[
/not[
?*0=93
\interpret
\]
/+
+*1
\interpret
/-
-*1
\interpret
/,
'*1
\interpret
/.
:1
\interpret
/>
+1
\interpret
/<
-1
\interpret
/[
?*1=0
\interpret
/find]
+0
?*0=91
\find]not[
\find][
/find]not[
?*0=93
\find]
?2=0
\find]dec
\interpret
/find]dec
-2
\find]
/find][
+2
\find]

/]
?*1=0
\interpret
/find[
-0
?*0=93
\find[not]
\find[]
/find[not]
?*0=91
\find[
?2=0
\find[dec
\interpret
/find[dec
-2
\find[
/find[]
+2
\find[

brainfuck in RIfP

, is not supported and . outputs cell in binary for now. Uses 8-bit cells.

@program=&^++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.#
@data=#^0000000000#
@nest=@#
@zero=0
@one=1
;tobinary
!program ^#=# endbinary
!program ^+=>>>>>>>>[<]@>[@>]<<<<<<<<<[@]^ tobinary
!program ^-=@>>>>>>>>@[<@]>[>]<<<<<<<<<[@]^ tobinary
!program ^>=>>>>>>>>>^ tobinary
!program ^<=<<<<<<<<<^ tobinary
!program ^[=@[>>>>>>>>@[<@]>[>]<<<<<<<<<[@]>>>>>>>>[<]@>[@>]<<<<<<<<<@[@^ tobinary
!program ^]=>>>>>>>>>@<<<<<<<<<]>>>>>>>>>[<<<<<<<<<@>>>>>>>>>@]<<<<<<<<<]^ tobinary
!program ^.=>.>.>.>.>.>.>.>.<<<<<<<<^ tobinary
!program #=# halt
;endbinary
!program &=&^ interpet
;interpret
!program ^#=# halt
!program ^@=@^ flip
!program ^>=>^ next
!program ^<=<^ prev
!program ^[=[^ sloop
!program ^]=]^ eloop
!program ^.=.^ out
!program #=# halt
;flip
!data ^0=^1 interpret
!data ^1=^0 interpret
!program #=# halt
;next
!data ^0=0^ ifoutofbounds
!data ^1=1^ ifoutofbounds
;prev
!data 0^=^0 interpret
!data 1^=^1 interpret
!data #^=#^0 interpret
;ifoutofbounds
!data ^#=^0# interpret
!data #=# interpret
;sloop
!data ^1=^1 interpret
;find]
!program ^#=# halt
!program ^@=@^ find]
!program ^>=>^ find]
!program ^<=<^ find]
!program ^[=[^ [sloop
!program ^]=]^ ]sloop
!program ^.=.^ find]
!program #=# halt
;[sloop
@nest @=@* find]
;]sloop
@nest @# interpret
@nest *=[] find]
;eloop
!data ^0=^0 interpret
;find[
!program #^=# halt
!program @^=^@ find[
!program >^=^> find[
!program <^=^< find[
!program [^=^[ [eloop
!program ]^=^] ]eloop
!program .^=^. find[
!program &^=& halt
;]eloop
!nest @# endeloop
!nest *=[] find[
;endeloop
!program ^[=[^ interper
;0out
!data ^0=^0 0out0
!data ^1=^1 0out1
!program #=# halt
;halt

brainfuck in SStack

#############################
# Program!Input             #
# Implements right infinite #
# tape                      #
# program stored in e and d #
# tape in c and f           #
# g stores nesting depth    #
# and is used for executing #
# command                   #
# 8 bit cells               #
# untested                  #
#############################


"1/a""1/b""33/c""0/d"
# Input program
[a\b/
 ;d;
 # If ! then exit loop
 [d\c/
  >c/b<"0/c"
 ]
]
~b~
# Because program is now stored in reverse move every command to stack e so program would be stored as it should be
[a\b/
 >d/e<
 [d\c/
  >c/b<"1/c"
 ]
]
~b~~c~"256/c""0/c"
# Execute instruction
[a\b/
 "0/g"
 "43/g"
# plus
 [g\e/
  +c/c+
  "1/g"
 ]
 [a\b/
  ~g~
  "0/d"
  [d\g
   "2/b"
  ]
 ~d~
 ]~b~
 "45/g"
# minus
 [g\e/
  -c/c-
  "1/g"
 ]
 [a\b/
  ~g~
  "0/d"
  [d\g/
   "2/b"
  ]
 ~d~
 ]~b~
 "62/g"
# move right
 [g\e/
  >f/c<
  "1/g"
 ]
 [a\b/
  ~g~
  "0/d"
  [d\g/
   "2/b"
  ]
 ~d~
 ]~b~
 "60/g"
# move left
 [g\e/
  >c/f<
  "1/g"
 ]
 [a\b/
  ~g~
  "0/d"
  [d\g/
   "2/b"
  ]
 ~d~
 ]~b~
 "44/g"
# input
 [g\e/
  ;c;
  "1/g"
 ]
 [a\b/
  ~g~
  "0/d"
  [d\g/
   "2/b"
  ]
 ~d~
 ]~b~
 "46/g"
# output
 [g\e/
  :c:
  "1/g"
 ]
 [a\b/
  ~g~
  "0/d"
  [d\g/
   "2/b"
  ]
 ~d~
 ]~b~
 "91/g"
# left bracket
 [g\e/
  "0/g"
  [c\g/
   [a\b/
    "0/g"
    >e/d<
    "91/g"
    [g\d/
     [a\b/
      ~g~
      "0/d"
       [d\g/
        "2/b"
       ]
       ~d~
     ]~b~
     ~g~+g/g+
    ]
    [a\b/
     ~g~
     "0/d"
     [d\g/
      "2/b"
     ]
     ~d~
   ]~b~
    "0/g"
    >e/d<
    "93/g"
    [g\d/
     [a\b/
      ~g~
      "0/d"
       [d\g/
        "2/b"
       ]
       ~d~
     ]~b~
     ~g~"0/d"[d\g/"0/b"~g~]~d~-g/g-
    ]~b~
   ]
  ]
 "1/g"
 ]
 [a\b/
  ~g~
  "0/d"
  [d\g
   "2/b"
  ]
 ~d~
 ]~b~>e/d<
 "93/g"
# right bracket
 [g\e/
  "0/g"
  [c\g/
   [a\b/
    "0/g"
    >d/e<
    "91/g"
    [g\d/
    "0/b"
    [a\b
     ~g~
     "0/d"
      [d\g/
       "2/b"
      ]
      ~d~
    ]~b~
    ~g~+g/g+
   ]
   [a\b/
    ~g~
    "0/d"
    [d\g/
     "2/b"
    ]
    ~d~
  ]~b~
   "0/g"
   >e/d<
   "93/g"
   [g\d/
    [a\b/
     ~g~
     "0/d"
      [d\g/
       "2/b"
      ]
      ~d~
    ]~b~
    ~g~"0/d"[d\g/"0/b"~g~]~d~-g/g-
   ]~b~
  ]
 "1/g"
 ]
 [a\b
  ~g~
  "0/d"
  [d\g/
   "2/b"
  ]
 ~d~
 ]~b~
 >e/d<
 "256/g"
 [c/g\
  "0/c"
 ]
  ~g~
  "0/d"
  [d\g/
   "2/b"
  ]
 ~d~
 ]~b~
]

brainfuck in TACC

It is modified version of my brainfuck-in-Uppercase=Lowercase interpreter. Input should also be character by character.

+3
^
[input
:1
<
+1
>
;
^
!33
]endinp
]input
[endinp
:1
<
+2
:2
^
:1
[dectozero
<
-1
^
!0
]set3
]dectozero
[set3
+3
^
>
[interpret
:1
<
+1
^
>
!43
]+
!45
]-
!44
],
!46
].
!60
]<
!62
]>
!91
][
!93
][
]interpret
[+
:2
<
>
<
+1
^
]interpret
[-
:2
<
>
<
-1
^
]interpret
[>
:2
<
-1
^
]interpret
[<
:2
<
-1
^
]interpret
[,
:2
<
>
;
^
]interpret
[.
:2
<
>
<
"
^
]interpret
[[
:2
<
>
<
!0
]find]
]interpret
[find]
:1
<
+1
^
>
<
!91
][inc
!93
][dec
]find]
[[inc
:3
<
+1
^
]find]
[[dec
:3
<
!0
]interpret
-1
^
]find]
[]
:2
<
>
<
!0
]interpret
[find[
:1
<
-1
^
>
<
!91
]]inc
!93
]]dec
]find[
[]inc
:3
<
+1
^
]find[
[]dec
:3
<
!0
]interpret
-1
^
]find[

brainfuck in Uppercase=Lowercase

// Memory is lied like this:
// IP,CP,Nesting depth, cell for unconditional jumps, 0, program, 0, Memory
// input is seperated from program by ! like in dbfi
// If you try to decrement 0 or IP goes out of bounds three exclamation marks would be printed and progam will halt
// set IP to 5
set 1 5
// start inputing
lbl input
inc 1 1
inp *1
dec *1 34 finsishinput
inc *1 34
dec 4 1 input
lbl finishinput
dec *1 33
set 2 1
inc 2 1
set 1 5
lbl interpet
inc 1 1
// if zero halt
dec *1 1 end
inc *1 1
// if 43 increment
dec *1 44 inc
inc *1 44
// if 44 input
dec *1 45 inp
inc *1 45
// if 45 decrement
dec *1 46 dec
inc *1 46
// if 46 output
dec *1 47 out
inc *1 47
// if 60 previous cell
dec *1 61 prev
inc *1 61
// if 62 next cell
dec *1 63 next
inc *1 63
// if 91 start loop
dec *1 92 startl
inc *1 92
// if 93 end loop
dec *1 94 endl
inc *1 94
dec 4 1 interpret
// +
lbl inc
inc *2 1
dec 4 1 interpret
// -
lbl dec
dec *2 1 error
dec 4 1 interpret
// >
lbl next
inc 2 1
dec 4 1 interpet
// <
lbl prev
dec 2 1 error
dec 4 1 interpet
// .
lbl out
out *2
dec 4 1 interpret
// ,
lbl inp
inp *2
dec 4 1 interpret
// [
lbl startl
// if cell is zero go back to matching ]
dec *2 1 nextcmd
inc *2 1
dec 4 1 interpet
// loop until matching ]
lbl nextcmd
inc 1 1
// if there is no instruction under IP then error
dec *1 1 error
inc *1 1
// if symbol is not [ or ] do nothing
dec *1 44 nextcmd
inc *1 44
dec *1 45 nextcmd
inc *1 45
dec *1 46 nextcmd
inc *1 46
dec *1 47 nextcmd
inc *1 47
dec *1 61 nextcmd
inc *1 61
dec *1 63 nextcmd
inc *1 63
// if symbol is [ inc nesting depth
dec *1 92 incnest
inc *1 92
// if symbol is ] dec nesting depth
dec *1 94 decnest
dec 4 1 nextcmd
lbl incnest
inc 3 1
dec 4 1 nextcmd
lbl decnest
// try to decrement nesting depth
// if it was already zero end loop
dec 3 1 interpet
dec 4 1 nextcmd
// ]
lbl endl
// if cell is zero continue executing
dec *2 1 interpret
inc *2 1
// loop until matching [
lbl prevcmd
dec 1 1 error
// if there is no instruction under IP then error
dec *1 1 error
inc *1 1
// if symbol is not [ or ] do nothing
dec *1 44 nextcmd
inc *1 44
dec *1 45 nextcmd
inc *1 45
dec *1 46 nextcmd
inc *1 46
dec *1 47 nextcmd
inc *1 47
dec *1 61 nextcmd
inc *1 61
dec *1 63 nextcmd
inc *1 63
// if symbol is [ inc nesting depth
dec *1 92 incnest2
inc *1 92
// if symbol is ] dec nesting depth
dec *1 94 decnest2
dec 4 1 prevcmd
lbl incnest2
inc 3 1
dec 4 1 prevcmd
lbl decnest2
// try to decrement nesting depth
// if it was already zero end loop
dec 3 1 interpet
dec 4 1 prevcmd
// if error print !!! and halt
lbl error
dec *1 print!
dec 4 1 error
lbl print!
inc *1 33
out *1
out *1
out *1

Cyclic Tag

Cyclic Tag interpreter in CDILOI

INP CODE
INP DATA
LBL CMD
IF @DATA @Y END
DEL @CODE CMD CODE
IF @CMD ; ;
IF @CMD 0 0
IF @CMD 1 1
IF A A CMD
LBL ;
CONC @CODE ; CODE
DEL @DATA X DATA
IF A A CMD
LBL 0
CONC @CODE 0 CODE
DEL @DATA X DATA
CONC @X @DATA DATA
IF @X 0 CMD
CONC @DATA 0 DATA 
IF A A CMD
LBL 1
CONC @CODE 1 CODE
DEL @DATA X DATA
CONC @X @DATA DATA
IF @X 0 CMD
CONC @DATA 1 DATA 
IF A A CMD
LBL END

Cyclic Tag interpreter in InputSet

Before you paste this program into interpreter you need to remove every line which starts with // and remove spaces at start of each line

//Input Initial Data And Program
input data
input program
//Execute Program forever
forever (
 for (program) {
  // if current character is ;
  if $ ; [
   replace 1 data
  ]
  // if current character is 1
  if $ 1 [
   // if left-most character in data is 1
   if (data/1) 1 [
    // if right-most character in data is 1 replace it with 11
    if (data/{(data)}) 1 [ 
     replace {(data)} data 11
    ]
    // if right-most character in data is 0 replace it with 01
    if (data/{(data)}) 0 [
     replace {(data)} data 01
    ]
   ]
  ]
  // if current character is 0
  if $ 0 [
   // if left-most character in data is 1
   if (data/1) 1 [
    // if right-most character in data is 0 replace it with 00
    if (data/{(data)}) 0 [ 
     replace {(data)} data 00
    ]
    // if right-most character in data is 1 replace it with 10
    if (data/{(data)}) 1 [
     replace {(data)} data 10
    ]
   ]
  ]
 }
)

Cyclic Tag in RIfP

Replace 1 in first line with initial data and 011;10;101 in second line with BCT program.

@data=^1#
;replaceprogram
@program=^011;10;101#
;interpret
$data
!data ^#=# halt
!program ^0=0^ is0
!program ^1=1^ is1
!program ^;=;^ is;
!program ^#=# loop
;is;
!data ^1=^ interpret
!data ^0=^ interpret
;is0
!data ^1=^1 append0
!data ^0=^0 interpret
;is1
!data ^1=^1 append1
!data ^0=^0 interpret
;append1
!data 0#=01# interpet
!data 1#=11# interpet
;append0
!data 0#=00# interpet
!data 1#=10# interpet
;loop
!data #=# replaceprogram

Deadfish

Deadfish in TailDot

Unlike interpreter on the page it has halt command #

c,x,>>,v,x,i,x,v,x,e,x,i,28,e,x,d,37,e,x,s,46,e,x,o,53,e,x,#,77,j,1,a,a,1,e,a,256,61,j,1,s,a,1,e,a,-1,61,j,1,o,a,e,a,256,61,j,1,v,a,j,1,a,a,1,e,a,0,1,s,a,1,e,a,0,1,j,68

SHITS

SHITS in CDILOI

This is modified version of binary brainfuck interpreter

// ! - flip bit and move to the first cell
// > - move right
// {...} - while loop
// * - output bit
// + - input bit
INP RCODE
CONC @RDATA 0! RDATA
CONC @LDATA ! LDATA
CONC ! @NEST NEST
LBL CMD
IF @RCODE @A HALT
DEL @RCODE CMD RCODE
CONC @CMD @LCODE LCODE
IF @CMD ! FLIP
IF @CMD > RIGHT
IF @CMD * OUT
IF @CMD + INP
IF @CMD { SLOOP
IF @CMD } ELOOP
IF A A CMD
LBL FLIP
DEL @RDATA BIT RDATA
IF @BIT 0 SET1
IF @BIT 1 SET0
LBL SET1
CONC 1 @RDATA RDATA
IF A A LEFT
LBL SET0
CONC 0 @RDATA RDATA
IF A A LEFT
LBL RIGHT
DEL @RDATA BIT RDATA
CONC @BIT @LDATA LDATA
IF @RDATA ! NEWR
IF A A CMD
LBL NEWR
CONC 0 @RDATA RDATA
IF A A CMD
LBL LEFT
DEL @LDATA BIT LDATA
CONC @BIT @RDATA RDATA
IF @LDATA ! CMD
IF A A LEFT
LBL OUT
DEL @RDATA BIT RDATA
CONC @BIT @RDATA RDATA
OUT @BIT
IF A A CMD
LBL INP
DEL @RDATA BIT RDATA
INP BIT
CONC @BIT @RDATA RDATA
IF A A CMD
LBL SLOOP
DEL @RDATA BIT RDATA
CONC @BIT @RDATA RDATA
IF @BIT 0 FIND}
IF A A CMD
LBL FIND}
DEL @RCODE CMD RCODE
CONC @CMD @LCODE LCODE
IF @CMD { INCNEST1
IF @CMD } DECNEST1
IF A A CMD
LBL INCNEST1
CONC * @NEST NEST
IF A A FIND}
LBL DECNEST1
IF @NEST ! CMD
DEL @NEST CMD NEST
IF A A FIND}
LBL ELOOP
DEL @RDATA BIT RDATA
CONC @BIT @RDATA RDATA
IF @BIT 1 FIND{
IF A A CMD
LBL FIND{
DEL @LCODE CMD LCODE
CONC @CMD @RCODE RCODE
IF @CMD { INCNEST2
IF @CMD } DECNEST2
IF A A CMD
LBL INCNEST2
CONC * @NEST NEST
IF A A FIND{
LBL DECNEST2
IF @NEST ! CMD
DEL @NEST CMD NEST
IF A A FIND{
LBL HALT

Underload

Underload in CDILOI

INP CODE
LBL EXEC
DEL @CODE CMD CODE
IF @CMD ( PUSH
IF @CMD ~ SWAP
IF @CMD : DUP
IF @CMD * CONC
IF @CMD a ENC
IF @CMD ^ EXECSTACK
IF @CMD ! POP
IF @CMD S OUT
IF A A EXEC
LBL PUSH
CONC | @STACK
LBL NEXTCHAR
DEL @CODE CMD CODE
IF @CMD ( INCNEST
IF @CMD ) DECNEST
CONC @CMD @STACK STACK
IF A A NEXTCHAR
LBL INCNEST
CONC ( @STACK STACK
CONC * @NEST NEST
IF A A NEXTCHAR
LBL DECNEST
IF @NEST @X EXEC
CONC ) @STACK STACK
IF A A NEXTCHAR
LBL SWAP
LBL ELEM1
DEL @STACK CMD STACK
CONC @ELEM1 @CMD ELEM1
IF @CMD | ELEM2
IF A A ELEM1
LBL ELEM2
DEL @STACK CMD STACK
CONC @ELEM2 @CMD ELEM2
IF @CMD | ENDELEM2
IF A A ELEM2
LBL ENDELEM2
CONC @ELEM1 @STACK STACK
CONC @ELEM2 @STACK STACK
LBL CLEARELEM1
IF @ELEM1 @X CLEARELEM2
DEL @ELEM1 CMD ELEM1
IF A A CLEARELEM1
CONC @ELEM2 @STACK STACK
LBL CLEARELEM2
IF @ELEM2 @X EXEC
DEL @ELEM2 CMD ELEM2
IF A A CLEARELEM2
LBL DUP
LBL ELEMDUP
DEL @STACK CMD STACK
CONC @ELEM1 @CMD ELEM1
IF @CMD | ENDDUP
IF A A ELEMDUP
LBL ENDDUP
CONC @ELEM1 @STACK STACK
CONC @ELEM1 @STACK STACK
IF A A CLEARELEM1
LBL CONC
LBL ELEM1CONC
DEL @STACK CMD STACK
IF @CMD | ELEM2CONC
CONC @ELEM1 @CMD ELEM1
IF A A ELEM1CONC
LBL ELEM2CONC
DEL @STACK CMD STACK
CONC @ELEM1 @CMD ELEM1
IF @CMD | ENDELEM2CONC
IF A A ELEM2CONC
LBL ENDELEM2CONC
CONC @ELEM1 @STACK STACK
IF A A CLEARELEM1
LBL ENC
LBL ELEMENC
DEL @STACK CMD STACK
CONC @ELEM1 @CMD ELEM1
IF @CMD | ENDENC
IF A A ELEMENC
LBL ENDENC
CONC @ELEM1 ( ELEM1
CONC ) @ELEM1 ELEM1
CONC @ELEM1 @STACK STACK
IF A A CLEARELEM1
LBL POP
LBL ELEMPOP
DEL @STACK CMD STACK
CONC @ELEM1 @CMD ELEM1
IF @CMD | CLEARELEM2
IF A A ELEMPOP
LBL EXECSTACK
LBL ELEMEXEC
DEL @STACK CMD STACK
CONC @CMD @ELEM1 ELEM1
IF @CMD | ENDEXEC
IF A A ELEMEXEC
LBL ENDEXEC
CONC @ELEM1 @CODE CODE
IF A A CLEARELEM1
LBL OUT
LBL ELEMOUT
DEL @STACK CMD STACK
CONC @CMD @ELEM1 ELEM1
IF @CMD | ENDOUT
IF A A ELEMOUT
LBL ENDEXEC
OUT @ELEM1
IF A A CLEARELEM1

Underload in Redefine Symbol

//Replace every Underload instruction with Redefine Symbol ones
[%][~]=
[:]["]=
[*][%+]=
[(][\[]=
[)][\]]=
//Since there is no a command in Redefine symbol I converted it like that:
// Push left bracket, concatenate top stack elements, push right bracket, swap top elements, concatenate top 
// elements
[a][\[\\\[\]+\[\\\]\]%+]=
[S][;$]=
[^][$.]=
?$.