Deadfish/Implementations (nonalphabetic and A-L)

__TOC__
Deadfish has been implemented in lots of different languages, both practical and esoteric. This page lists the first part. The next part is at: Deadfish/Implementations (M-Z)
== Юᓂ곧⎔ ==
Implementation in the non-ASCII language Юᓂ곧⎔. Accepts the standard `idso` inputs.
⌂ «»
☹
 ❝Δις Юᓂ곧⎔ κοδε μπασεδ ον α Δεαδφις Ϲ ιντερπρετερ μπι Ασδφ
 κονβερτεδ αντ τεστεδ μπι Σάλπιγξ❞
 ℤ 事 ← ☰।
 писать «“⁌☷☶⁍⁌☷☶⁍”»।
 ∀«।।»
 ☹
 ቁምፊ 工।
 工← получатзнак «»।
 ¿ «事⇔᠒᠕᠖∨事⇔−☱» 事←☰।
 ¿ «工⇔‘⁌☱☵☱⁍’» ∆事।
 ¬¿«工⇔‘⁌☱☴☴⁍’» ∇事।
 ¬¿«工⇔‘⁌☱☵☷⁍’» писать «“﹪ℤ␊” ¦ 事»।
 ¬¿«工⇔‘⁌☱☶☳⁍’» 事×←事।
 ¬писать «“⁌☷☶⁍⁌☷☶⁍”»।
 ☺
☺
== ثلاثي ==
ﻮﻨﻴﺳﺎﻃ ﺭﺩ ﺫ ﻦﺴﻃﺮﺤﻃﺫ ﻲﺼﻃ ﺎﻧﺎﺴﻃ ﻮﻃﺎﺳﺎﻃ ﺎﻘﻃﺭ ﻖﻘﻗ ﻲﻘﻃﺭ ﺎﻃﻮﺴﻃ ﺎﻄﻴﺴﻃ ﻞﻃ ﻁ ﻑ ﻲﺼﻃ ﺎﻧﺎﺴﻃ ﺎﻘﻃﺭ ﻖﺒﺟ ﻲﻘﻃﺭ ﻲﺻﺎﻃ ﺎﻄﻴﺴﻃ ﺩﺍﺩﺎﻓ ﻑ ﻦﺴﻃﺮﺤﻃﺫ ﻖﻠﺳ ﺲﺳ ﻦﺣﺮﻤﻨﻃ ﻁ ﺢﺤﻤﻠﻃﺭ ﻲﺼﻃ ﺎﻧﺎﺴﻃ ﺎﻘﻃﺭ ﻕ ﻲﻘﻃﺭ ﻲﺻﺎﻃ ﺎﻄﻴﺴﻃ ﺍﺩﺍﺩﺎﻓ ﻑ ﻦﺴﻃﺮﺤﻃﺫ ﻖﻠﺳ ﺱﺪﺳ ﺪﺣﺮﻤﻨﻃ ﻁ ﺢﺤﻤﻠﻃﺭ ﻲﺼﻃ ﺎﻧﺎﺴﻃ ﺎﻘﻃﺭ ﻖﻴﺒﺟ
ﻲﻘﻃﺭ ﻲﺻﺎﻃ ﺎﻄﻴﺴﻃ ﺍﺩﻭﺪﻓ ﻑ ﻦﺴﻃﺮﺤﻃﺫ ﻖﻠﺳ ﺲﺴﺳ ﺲﻗﺭ ﻁ ﺢﺤﻤﻠﻃﺭ ﻲﺼﻃ ﺎﻧﺎﺴﻃ ﺎﻘﻃﺭ ﺎﻘﻳ ﻲﻘﻃﺭ ﻲﺻﺎﻃ ﺎﻄﻴﺴﻃ ﻱﺩﻭﺩﺎﻓ ﻑ ﻦﺴﻃﺮﺤﻃﺫ ﻖﻠﺳ ﺲﺳ ﻂﻔﻃ ﻁ ﺢﺤﻤﻠﻃﺭ ﻲﺼﻃ ﺍﺩﺍﺪﻓ ﺎﻘﻃﺭ ﻮﻧﺭ ﻲﻘﻃﺭ ﻲﺻﺎﻃ ﺎﻄﻴﺴﻃ ﻭﺩﺪﻓ ﻑ ﺢﺤﻤﻠﻃﺭ ﻖﻠﺳ ﺲﻃ ﺢﺤﻤﻠﻃﺭ ﻁ ﺯﺭ ﻭﺰﻳﺯﺯ ﻢﺿ ﺐﺤﺛ ﻁ ﺲﻃﺮﻃ
The United States Department of State has issued a circular to the Qatari authorities to stop the spread of the coronavirus. The United States Department of State has issued a circular to the Qatari authorities to stop the spread of coronavirus. The United States Department of State has issued a circular to the Qatari authorities to stop the spread of coronavirus. The United States Department of State has issued a circular to the Qatari authorities to stop the spread of coronavirus. The most important thing is that the Qatari people are not afraid of losing their jobs. ... Whiz
-- Google Translate
And nice reply y we dominate he rustles Stomp Drop Trickle he drips I mediate I slap I so he cuts I pull I drip Qbj he drips he sucks I slap Dadaf P we have a regurgitation Regurgitation I deprive you I will carry it Touch Drop Drop Q Distills he sucks Sneak Eddaf P Underline Regurgitation Sixth Durhamant I will carry Catch Touch Drop Gypsy
he drips he stuns Adove in Nestorize Regurgitation Saqr I will carry Suck Touch Drop Drop Drop Distills Suck Jump in Underminish Ss Jump I will have to Trick Push Drop Ner Distilling Suck Slap P I'll have to regurgitate middle I'll have to button and button Sign Search I Underline
-- Microsoft Translate
You are the only person who has ever been able to respond to a human rights defender, the most dangerous person in the world, the most dangerous person in the world, the most dangerous person in the world, the most dangerous person in the world, the most dangerous person in the world, the most dangerous person in the world, the most dangerous person in the world, the most dangerous person in the world, the most dangerous person in the world, the most dangerous person in the world, the most dangerous person in the world, the most dangerous person, the most dangerous person in the world, the most dangerous person in the world, the most dangerous person, the most dangerous person in the world, the most dangerous person, the most dangerous person, the most dangerous person in the world, the most dangerous person.
The Holy Land of Israel, the Holy Land of Israel, the Holy Land of Israel, the Holy Land of Israel, the Holy Land of Israel, the Holy Land of Israel, the Holy Land of Israel, the Holy Land of Israel, the Holy Land of Israel, the Holy Land of Israel, the Holy Land of Israel, the Holy Land of Israel, the Holy Land of Israel, the Holy Land of Israel, the Holy Land of Israel, the Holy Land of Israel, the Holy Land of Israel, the Holy Land of Israel, the Holy Land of Israel, the Holy Land of Israel, the Holy Land, the Holy Land of Israel, the Holy Land, the Holy Land of Israel, the Holy Land, the Holy Land of Israel, the Holy Land, the Holy Land, the Holy Land, the Holy Land, the Holy Land, the Holy Land, the Holy Land, the Holy Land of Israel, the Holy Land, the Holy Land, the Holy Land, the Holy Land, the Holy Land, the Holy Land, the Holy Land, the Holy Land, the Holy Land, the Holy Land, the Holy Land, the Holy Land, the Holy Land, the Holy Land, the Holy Land, the Holy Land, the Holy Land, the Holy Land, the Holy Land, the Holy Land, the Holy Land, the Holy Land, the Holy Land,
-- ModernMT
== תלת ==
וניסאט רד ן נסטרחטן יצט אנאסט וטאסאט אקטר קקק יקטר אטוסט אטיסט לט ט פ יצט אנאסט אקטר קבג יקטר יצאט אטיסט דאדאפ פ נסטרחטן קלס סס נחרמנט ט חחמלטר יצט אנאסט אקטר ק יקטר יצאט אטיסט אדאדאפ פ נסטרחטן קלס סדס דחרמנט ט חחמלטר יצט אנאסט אקטר קיבג
יקטר יצאט אטיסט אדודפ פ נסטרחטן קלס ססס סקר ט חחמלטר יצט אנאסט אקטר אקי יקטר יצאט אטיסט ידודאפ פ נסטרחטן קלס סס טפט ט חחמלטר יצט אדאדפ אקטר ונר יקטר יצאט אטיסט ודדפ פ חחמלטר קלס סט חחמלטר ט זר וזיזז מף בחך ט סטרט
Venisat Red n Nestrechten Ycet Anast and Tasat Akter Kekk Yakter Adust Agust Lat T P Ycet Anast Ekter Kabeg Yaktar Yitzat Await Dadap P Nester Kells Ses Nehrment T Hakhmelter Ycet Anast Akter K Yaktar YitSat Ativist Adadap P Nestrechten Kels Seds Dekhment T Hakhmelter Ycet Anast Akter Kibag
Yaktar Yitzat Atypist Adudef P Nestrechten Kells Sesses Saker T Hakhmelter Ycet Anast Akter Aki Yaktar Yitset Aetist Yedodap P Nasterkhten Kels Ses Teft T Hachamlater Ycet Addep Akter Venner Yakter Yitzat Aetist Vaddef P Hakhmelter Kels Set Khamtar T Stranger and Moved Mf Bakhtar T Strat
-- Microsoft Translate
== A:; ==
Interprets one instruction per line
 v:-1.0;w:256.0;u:\n;t:1;r:0;j:i;l:d;b:s;o:o;c:>>;p:c;?:r:=:v:1;r:0;?:r:=:w:1;r:0;i:q;?:q:=:o:3;p:r;p:u;g:10;?:q:=:j:2;a:r:t;g:10;?:q:=:l:2;s:r:t;g:10;?:q:=:b:2;m:r:r;g:10;p:u;g:10
== Ada ==
with Ada.Text_IO; use Ada.Text_IO;
with Ada.Containers.Indefinite_Holders;
with Ada.Integer_Text_IO;
procedure Deadfish is
 package String_Holder is new Ada.Containers.Indefinite_Holders(String);
 use String_Holder;
 value_output : Natural := 0;
 str_input : String_Holder.Holder := To_Holder("");
begin
 Prompt :
 loop
 Put(">> ");
 String_Holder.Replace_Element(str_input, Get_Line);
 for rg in str_input.Element'Range loop
 case str_input.Element(rg) is
 when 'i' | 'x' => 
 case value_output is
 when 255 => value_output := 0;
 when others => value_output := Natural'Succ(value_output);
 end case;
 when 'd' => 
 case value_output is
 when 257 => value_output := 0;
 when 0 => null;
 when others => value_output := Natural'Pred(value_output);
 end case;
 when 's' | 'k' => 
 case value_output is
 when 16 => value_output := 0;
 when others =>value_output := value_output * value_output;
 end case;
 when 'o' | 'c' => Ada.Integer_Text_IO.Put(value_output, Width => 0); Put_Line("");
 when others => null;
 end case;
 end loop;
 end loop Prompt;
end Deadfish;
== APL ==
∇Deadfish;x
 x ← 0
line:
 ⍞ ← '>> '
 { x ∘← (~x∊¯1 256) × x
 ⍵∊'ix': x ∘← x + 1
 ⍵∊'d': x ∘← x - 1
 ⍵∊'sk': x ∘← x * 2
 ⍵∊'oc': ⎕ ← x
 }¨⍞
 → line
∇
== APLBAONWSJAS ==
EXECUTE(Deadfish)
== ARMLite ==
Maximum program length is 128 due to ARMLite restrictions.
; We can't use 256 as an immediate in ARMLite, nor -1.
; so we will use custom constants instead.
 mov r10, #1
 sub r11, r11, r10 ; r11 = -1
 lsl r10, r10, #8 ; r10 = 256
; Enter string
 mov r12, #program
 str r12, .ReadString
; loop through the program, reading
loop:
; load r1'th char from beginning
 ldrb r2, [r12 + r1]
; if r2 is null, end instantly
 cmp r2, #0
 cmp r2, # 104 ; h
 beq interpret_h
 cmp r2, #105 ; i
 beq interpret_i
 cmp r2, #100 ; d
 beq interpret_d
 cmp r2, #115 ; s
 beq interpret_s
 cmp r2, #111 ; o
 beq interpret_o
end_loop:
 add r1, r1, #1
 b loop
interpret_h: halt
interpret_i:
; add r0 to 1. If R0 == 256, make R0 zero.
 add r0, r0, #1
 b check_zero
interpret_d:
 sub r0, r0, #1
 b check_zero
interpret_s:
; armlite has no 'mul'...
 mov r3, r0
 mov r4, #0
mul_loop:
 add r4, r4, r0
 sub r3, r3, #1
 cmp r3, #0
 bgt mul_loop
 mov r0, r4
 b check_zero
interpret_o:
 str r0, .WriteUnsignedNum
 b check_zero
check_zero: ;set r0 to zero after operation
 cmp r0, r10
 beq set_zero
 cmp r0, r11
 beq set_zero
 b end_loop
set_zero:
 mov r0, #0
 b end_loop
program: .block 128
== A Slow Language ==
r0:rI~rd
 x _^"i"d
 d=:r1+:rd
 d^ l
 r"d"d
 d=:r1-:rd
 d^ l
 r"s"d
 d=:r^*:rd
 d l
 r"o"d
 d=:r^o:rd
 d l l
 O r:r^F1+^*d
 A d-10^=0:rvd
 v dr:=0:rvd
 u l l l
== Attache ==
?? state-ful deadfish interpreter
acc := 0
line := ""
deadfish[code] :=
 ForEach[code,
 If[_ = "i", acc := acc + 1];;
 If[_ = "d", acc := acc - 1];;
 If[_ = "s", acc := acc ^ 2];;
 If[_ = "o", Print[acc]];;
 If[acc = -1 or acc = 256, acc := 0]
 ]
DoWhile[line /= nil,
 deadfish[line];;
 line := Prompt[">> "]
]
Or, with the langs library:
Needs[$langs]
acc := 0
line := ""
DoWhile[line /= nil,
 acc := deadfish[line, acc];;
 line := Prompt[">> "]
]
== AWK ==
It won't display the prompt, but other than that is complete.
sub(/o/,x=x*(x>0&&x-256)*x^/s/+/i/-/d/)
== Bash ==
#!/bin/bash
no=0
while true; do
	((no==256||no<0)) && no=0
	echo -n '>> ' # prompt
	if read; then
		case $REPLY in
			d) ((no--)) ;;
			i) ((no++)) ;;
			o) echo $no ;;
			s) no=$((no*no)) ;;
			*) : ;;
		esac
	else
		echo # on EOF
	fi
done
== Batch ==
@echo off
:start
set/pcmd=^>^>
if %cmd%==i set /a acc=%acc%+1
if %cmd%==d set /a acc=%acc%-1
if %cmd%==s set /a acc=%acc%*%acc%
if %cmd%==o echo %acc%
if %acc%==256 set %acc%=0
if %acc%==-1 set %acc%=0
goto start
Here is another variant with an additional debug command "?" and the halt command "h".
@echo off
set debug=0
:start
set cmd=0
set/pcmd=^>^>
if %cmd%==i set/aacc=%acc%+1&if %debug%==1 echo %acc%+1
if %cmd%==d set/aacc=%acc%-1&if %debug%==1 echo %acc%-1
if %cmd%==s set/aacc=%acc%*%acc%&if %debug%==1 echo %acc%*%acc%
if %cmd%==o echo %acc%
if %cmd%==h set acc=0&set debug=0&goto :eof
if %cmd%==? (if %debug%==0 (set debug=1) else (set debug=0))
if %acc%==256 set acc=0
if %acc%==-1 set acc=0
goto start
== GNU bc ==
/*Bc does not support character I/O. Here is an alternate mapping:
 *0:i
 *1:d
 *2:s
 *3:o
 */
ac=0
while(1) {
 if(ac==-1)ac=0
 if(ac==256)ac=0
 print ">> "
 a=read()
 if(a==0)ac+=1
 else if(a==1)ac-=1
 else if(a==2)ac*=ac
 else if(a==3)print ac
}
quit
== Befunge-93 ==
v Deadfish in Befunge
0
>0" >>">:vv <
,# _$:vv-*5+7*44
+ v < _:*v 
: $ v^,_v^.< > 
5> ~ >#$>:375**-v
^ < $ #v-*:*25:_$1+
^#-*65-*99:_$1- #v
 ^ _$0~^ >:1+v
 -^> #1-#_1+:48:**
== Befunge-98 ==
0v ^;#+1$< ;;#-1$< ;;#*:$< ;.:$<
>>#@~:'i-!#^_:'d-!#^_:'s-!#^_:'o-!#^_
^ > :f1+:*-!#v_:01--!#v_
^ 0$< <
== Boo ==
 /* Deadfish in Boo */
 # by Chris Pressey
 // Hallowe'en 2012
 a = 0
 while true:
 if a < 0 or a == 256:
 a = 0
 c = prompt(">> ")
 if c == 's':
 a *= a
 elif c == 'i':
 a += 1
 elif c == 'd':
 a -= 1
 elif c == 'o':
 print(a)
== Brainfuck ==
Implementation by User:David.werecat, reads one line of input at a time (for compatibility with most brainfuck interpreters) and interprets only one instruction per line
 >+[<++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++..-------
 -----------------------.[-]>>[-]+>,----------[-----------------------------
 -------------------------------------------------------------[-----[------[
 ----[<->[-]]<[>>>[-]>[-]>[-]>[-]<<<<[>+>+>+<<<-]>[>[<<+>>-]>[>+<-]>[<+<+>>-
 ]<<<-]<<<-]>]<[>>>[-]>[-]>[-]>[-]>[-]>[-]<<<<<<[->+>>>>>+<[-]+<<<<---------
 -[>>>>[<++++++++++<<->>>-]<+<<<-]>>>[<<<+>>>-]<<+>>>[-]+<<<----------[>>>[<
 ++++++++++<->>-]<+<<-]>>[<<+>>-]<+<<<]>>>>[-]>[-]<<[>+<<<<[-]++++++++++++++
 ++++++++++++++++++++++++++++++++++>>>[<<<+>>>-]<<<.>>>]>[<<<<[-]+++++++++++
 +++++++++++++++++++++++++++++++++++++>>[<<+>>-]<<.>>>>-]<<[<<[-]+++++++++++
 +++++++++++++++++++++++++++++++++++++>>[<<+>>-]<<.>>]<<[-]+++++++++++++++++
 +++++++++++++++++++++++++++++++>[<+>-]<.[-]++++++++++.---------->>>>>>[<<<<
 <<+>>>>>>-]<<<<<<<<-]>]<[>>+<<-]>]<[>>>[-]+>[-]<<[>[-]>+<<-]>>-[<<+>>-]<<>[
 <+>-]<<<-]>]<[>-<-]>+[,----------]<<]
Implementation by User:None1 and generated by BFFuck, it has an interactive shell and interprets only one instruction per line, but it runs on 8 bit cells with wrapping
>>>>>>>>>>>>>>>[-]>+[<<++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.[-]++++++++++++++++++++++++++++++++.[-]>>>,>,>[-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++<<<<<[-]<[-]>>>>>>[<<<<<<+>>>>>>-]+<<[<<<<->+>>>-]<<<[>>>+<<<-]<[>>>>>>-<<<<<<[-]]>[-]<[-]>>>>>>[<<<<<+<+>>>>>>-]<<<<<[>>>>>+<<<<<-]<[>>+<<[-]]>>>>>>[-]++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++<<<<<[-]<[-]>>>>>>[<<<<<<+>>>>>>-]+<<[<<<<->+>>>-]<<<[>>>+<<<-]<[>>>>>>-<<<<<<[-]]>[-]<[-]>>>>>>[<<<<<+<+>>>>>>-]<<<<<[>>>>>+<<<<<-]<[>>-<<[-]]>>>>>>[-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++<<<<<[-]<[-]>>>>>>[<<<<<<+>>>>>>-]+<<[<<<<->+>>>-]<<<[>>>+<<<-]<[>>>>>>-<<<<<<[-]]>[-]<[-]>>>>>>[<<<<<+<+>>>>>>-]<<<<<[>>>>>+<<<<<-]<[>>>>>>>[-]<<<<<[>>>>>+<<<<<<<<<<<<<<<<<<<<+>>>>>>>>>>>>>>>-]<<<<<<<<<<<<<<<[>>>>>>>>>>>>>>>+<<<<<<<<<<<<<<<-]>>>>>>>>>>>>>>[-]<[-]>>[<<+>>-]<<[>>>>>>>[<<<<<+<+>>>>>>-]<<<<<<[>>>>>>+<<<<<<-]<-][-]]>>>>>>[-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++<<<<<[-]<[-]>>>>>>[<<<<<<+>>>>>>-]+<<[<<<<->+>>>-]<<<[>>>+<<<-]<[>>>>>>-<<<<<<[-]]>[-]<[-]>>>>>>[<<<<<+<+>>>>>>-]<<<<<[>>>>>+<<<<<-]<[>>[<<<<<<<<<<<<<<<+>>>>>>>>>>>>>>+>-]<<<<<<<<<<<<<++++++++++<<[->+>-[>+>>]>[+[-<+>]>+>>]<<<<<<]>>[-]>>>++++++++++<[->-[>+>>]>[+[-<+>]>+>>]<<<<<]>[-]>>[>++++++[-<++++++++>]<.<<+>+>[-]]<[<[->-<]++++++[->++++++++<]>.[-]]<<++++++[-<++++++++>]<.[-]<<[-<+>]<[-]>>>>>>>>>>>>>>[>+<-][-]++++++++++.[-]<[-]]>>>]
A shorter alternative compiled with a higher version of BFFuck.
>>>>>>>>>>>>>>>[-]>+[<<++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.[-]++++++++++++++++++++++++++++++++.[-]>>>,>,>[-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++<<<<<[-]<[-]>>>>>>[<<<<<<+>>>>>>-]+<<[<<<<->+>>>-]<<<[>>>+<<<-]<[>>>>>>-<<<<<<[-]]>[-]<[-]>>>>>>[<<<<<+<+>>>>>>-]<<<<<[>>>>>+<<<<<-]<[>>+<<[-]]>>>>>>[-]++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++<<<<<[-]<[-]>>>>>>[<<<<<<+>>>>>>-]+<<[<<<<->+>>>-]<<<[>>>+<<<-]<[>>>>>>-<<<<<<[-]]>[-]<[-]>>>>>>[<<<<<+<+>>>>>>-]<<<<<[>>>>>+<<<<<-]<[>>-<<[-]]>>>>>>[-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++<<<<<[-]<[-]>>>>>>[<<<<<<+>>>>>>-]+<<[<<<<->+>>>-]<<<[>>>+<<<-]<[>>>>>>-<<<<<<[-]]>[-]<[-]>>>>>>[<<<<<+<+>>>>>>-]<<<<<[>>>>>+<<<<<-]<[>>>>>>>[-]<<<<<[>>>>>+<<<<<<<<<<<<<<<<<<<<+>>>>>>>>>>>>>>>-]<<<<<<<<<<<<<<<[>>>>>>>>>>>>>>>+<<<<<<<<<<<<<<<-]>>>>>>>>>>>>>>[-]<[-]>>[<<+>>-]<<[>>>>>>>[<<<<<+<+>>>>>>-]<<<<<<[>>>>>>+<<<<<<-]<-][-]]>>>>>>[-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++<<<<<[-]<[-]>>>>>>[<<<<<<+>>>>>>-]+<<[<<<<->+>>>-]<<<[>>>+<<<-]<[>>>>>>-<<<<<<[-]]>[-]<[-]>>>>>>[<<<<<+<+>>>>>>-]<<<<<[>>>>>+<<<<<-]<[>>[<<<<<<<<<<<<<<<+>>>>>>>>>>>>>>+>-]<<<<<<<<<<<<<<[-]>[-]+>[-]+<[>[-<-<<[->+>+<<]>[-<+>]>>]++++++++++>[-]+>[-]>[-]>[-]<<<<<[->-[>+>>]>[[-<+>]+>+>>]<<<<<]>>-[-<<+>>]<[-]++++++++[-<++++++>]>>[-<<+>>]<<]<[.[-]<]<[-]>>>>>>>>>>>>>>[>+<-][-]++++++++++.[-]<[-]]>>>]
== Buffalo! ==
This is a full implementation when run under the Python interpreter (which has unbounded integers). Output of large numbers (beyond about 1000) is quite slow, since exponentiation, multiplication, division and even addition have to be implemented from scratch using unary increment/decrement, but it gets there in the end. Characters other than 'i', 'd', 's' and 'o' have arbitrary interpretation.
Unfortunately it's too large to include on the page, but it's here: 
== Burlesque ==
{?i ?d S[ J}j{{'i 'd 's 'o}jFi}m[si)bx{J{-1==}{256==}m|{256.%}if}IC0je!
== C ==
<nowiki>
/* <-- Deadfish Interpreted Computer Language --> */
/* <-- Programmed by Jonathan Todd Skinner --> */
/* <-- Include Header File --> */
/* Updated the Code to Remove Uneeded Header Includes - JTS */
#include <stdio.h>
/* <-- Declare some variables --> */
unsigned int x; /* make a positive integer and call it x */
char usrinput; /* string to hold user input */
/* <-- Declare a function --> */
void entercommand(void);
/* <-- Start Main Function --> */
int main(void)
{
	/* At beginning of x is always 0 */
	x = 0;
	entercommand();
}
/* <-- Enter Command --> */
void entercommand(void)
{
	/* Accept User Input */
	printf(">> "); /* output shell symbol */
	scanf("%c",&usrinput); /* scan for user input that is char */
	/* Check for commands and do action */
	/* Make sure x is not greater then [sic] 256 */
	if(x == 256) x = 0;
	if(x == -1) x = 0;
	if(usrinput == 'i')
	{
		x++;
		entercommand();
	}		
	else if(usrinput == 'd')
	{
		x--;
		entercommand();
	}
	else if(usrinput == 'o')
	{
		printf("%d\n",x);
		entercommand();
	}
	else if(usrinput == 's')
	{
		x=x*x;
		entercommand();
	}
	else
	{
		printf("\n");
		entercommand();
	}
}
</nowiki>
Here's a slightly cleaned up version:
<nowiki>
/* <-- Deadfish Interpreted Computer Language --> */
/* <-- Original programmed by Jonathan Todd Skinner --> */
/* <-- Dumb stuff removed by some other guy --> */
#include <stdio.h>
int main(void)
{
 unsigned int x = 0;
 while(1) {
 char input; 
 printf(">> "); 
 scanf("%c",&input); 
 if(x == 256 || x == -1) 
 x = 0;
 
 switch(input) {
 case 'i':
 ++x;
 break;		
 	 case 'd':
	 --x;
	 break;
	 case 'o':
	 printf("%d\n",x);
	 break;
	 case 's':
	 x*=x;
	 break;
 default:
	 printf("\n");
	 break;
 }
 }
}
</nowiki>
There is a horribly short interpreter (I won't add ">>", since it wastes a lot of code):
<nowiki>
/* <-- By:Asdf --> */
#include<stdio.h>
int main(){
 int x=0;
 for(;;){
 char i;
 i=getchar();
 if(x==256||x==-1)x=0;
 if(i=='i')++x;
 	else if(i=='d')--x;
	else if(i=='o')printf("%d\n",x);
	else if(i=='s')x*=x;
 else printf("\n");
 }
}
</nowiki>
Unfortunately, many inplementers use input. It would be a lot shorter if it is predefined:
/* <-- By:Asdf --> */
#include<stdio.h>
int main(){
 int ptr=0, x=0;
 char c[10000]="";//Code goes here
 for(;c[ptr]!='\0';++ptr){
 if(x==256||x<0)x=0;
 if(c[ptr]=='i')++x;
 	else if(c[ptr]=='d')--x;
	else if(c[ptr]=='o')printf("%d\n",x);
	else if(c[ptr]=='s')x*=x;
 else printf("\n");
 }
}
Also, the most horrible (but short) interpreter (spaghetti code):
 #include <stdio.h> //By: Positron
 int main(){int x=0,i;a:i=getchar();if(x==256||x==-1)x=0;if(i=='i')++x;else if(i=='d')--x;else if(i=='o')printf("%d\n",x);else if(i=='s')x*=x;else putchar(10);goto a;} 
or in a more readable way:
 /*By: Positron*/
 #include <stdio.h>
 
 int main()
 {
 	int x=0,i;
 	a:
 	i=getchar();
 	if(x==256||x==-1)
 		x=0;
 	if(i=='i')
 		++x;
 	else if(i=='d')
 		--x;
 	else if(i=='o')
 		printf("%d\n",x);
 	else if(i=='s')
 		x*=x;
 	else
 		putchar(10);
 	goto a;
 }
Here's a slightly shorter (yet very unreadable) interpreter:
<nowiki>
/* By: Presauced */
#include<stdio.h>main(){int x=0,i;for(;;){ 
i=getchar();if(x==256||x==-1)x=0;if(i=='i')
++x;else if(i=='d')--x;else if(i=='o')printf(
"%d\n",x);else if(i=='s')x*=x;else puts("\n");}}
</nowiki>
With only for loops:
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
{
 for(argv[0] = (char *)malloc(16); 0; 0);
 for(argv[0][0] = 1; argv[0][0] < 15; argv[0][argv[0][0]] = 0, argv[0][0]++);
 for(0; argv[0][0] != 'h' && ((signed char *)(argv[0]))[0] != -1; printf(">> "), ((signed char *)(argv[0]))[0] = getc(stdin), printf("\n")){
 for(0; argv[0][0] == 'i'; *((int *)(argv[0] + 1)) += 1, argv[0][0] = 0);
 for(0; argv[0][0] == 'd'; *((int *)(argv[0] + 1)) -= 1, argv[0][0] = 0);
 for(0; argv[0][0] == 's'; *((int *)(argv[0] + 1)) *= *((int *)(argv[0] + 1)), argv[0][0] = 0);
 for(0; argv[0][0] == 'o'; printf("%d\n", *((int *)(argv[0] + 1))), argv[0][0] = 0);
 for(0; *((int *)(argv[0] + 1)) == -1 || *((int *)(argv[0] + 1)) == 256; *((int *)(argv[0] + 1)) = 0); }
 for(free(argv[0]); 0; 0);
}
== C# ==
 public class Deadfish {
 private static int x = 0;
 private static Dictionary<char, Action> Commands = new Dictionary<char, Action> {
 { 'i', () => ++x },
 { 'd', () => --x },
 { 's', () => x *= x },
 { 'o', () => Console.WriteLine(x) }
 };
 static void Main(string[] args) {
 Action prompt = () => {
 Console.Write(">> ");
 Console.Out.Flush();
 };
 prompt();
 int cmd;
 while ((cmd = Console.Read()) != -1) {
 char command = Convert.ToChar(cmd);
 if (!Environment.NewLine.Contains(command)) {
 x = x == 256 || x < 0 ? 0 : x;
 (Commands.ContainsKey(command) ? Commands[command] : () => Console.WriteLine())();
 prompt();
 }
 }
 }
 }
another C# implementation
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;
namespace Deadfish_Interpreter
{
 class Program
 {
 static void Main(string[] args)
 {
 StreamReader sr = new StreamReader(args[0]);
 string code = sr.ReadToEnd();
 code = code.Replace(((char)13).ToString(), "");
 int cell = 0;
 foreach (char c in code)
 {
 if (c == 'i')
 {
 cell++;
 }
 else if (c == 'd')
 {
 cell--;
 }
 else if (c == 's')
 {
 int i = cell * cell;
 cell = i;
 }
 else if (c == 'o')
 {
 Console.Write(cell);
 }
 if (cell == -1 || cell == 256)
 {
 cell = 0;
 }
 }
 Console.ReadLine();
 }
 }
}
Here is a large C# implementation written in only one statement by BoundedBeans. It's possibly a bit too large for this page.
== C++ Codegolfed ==
//By: Areallycoolusername
// Supports one-liners
#include <iostream> 
using namespace std;
int main() {
int acc = 0; 
char a;
do {
 std::cout << ">> ";
 std::cin >> a;
 if(a=='i') { 
 acc++;
 }
 if(a=='d') { 
 acc--;
 }
 if(a=='s') {
 acc *= acc;
 }
 if(a=='o') { 
 std::cout << acc << endl;
 } 
 if(acc<0||acc==256) { 
 acc = 0;
 }
} while(a!='h');
return 69; //For the lols
}
Another implementation, based on the previous implementation:
// Implementation by Tsuki
#include<iostream>
int main(){int ac=0;char a;do{std::cout<<">>";std::cin>>a;switch(a){case'i':ac++;break;case'd':ac--;break;case's':ac*=ac;break;case'o':std::cout<<ac<<'\n';break;}if(ac<0||ac==256){ac=0;}}while(a!='q');return 0;}
== C++ templates ==
<nowiki>
#include <iostream>
//
#define PROGRAM i,i,i,i,i,i,i,i,i,i,i,i,i,i,i,i,o,s,i,o,i,i,i,i,i,i,i,s,s,s,o
//
template <char n, typename Ns>
struct Cons {
 static void print() {
 Ns::print();
 std::cout << n;
 }
};
struct Nil {
 static void print() {}
};
template <typename Ms, typename Ns> struct Append;
template <typename Ns>
struct Append<Nil, Ns> {
 typedef Ns String;
};
template <char m, typename Ms, typename Ns>
struct Append<Cons<m, Ms>, Ns> {
 typedef Append<Ms, Ns> Next;
 typedef Cons<m, typename Next::String> String;
};
#define INS(name, expr) \
 struct name { \
 template <int n, typename Out> struct Result { \
 static const int value = expr; \
 typedef Out Output; \
 }; \
 }
INS(i, n + 1);
INS(d, n - 1);
INS(s, n * n);
template <int n> struct DecimalLoop;
template <> struct DecimalLoop<0> {
 typedef Nil String;
};
template <int n> struct DecimalLoop {
 typedef DecimalLoop<n / 10> Next;
 typedef Cons<'0' + (n % 10), typename Next::String> String;
};
template <int n> struct ToDecimal;
template <> struct ToDecimal<0> {
 typedef Cons<'\n', Cons<'0', Nil>> String;
};
template <int n> struct ToDecimal {
 typedef Cons<'\n', typename DecimalLoop<n>::String> String;
};
struct o {
 template <int n, typename Out> struct Result {
 static const int value = n;
 typedef typename Append<typename ToDecimal<n>::String, Out>::String Output;
 };
};
template <int n> struct Wrap {
 static const int value = n < 0 || n == 256 ? 0 : n;
};
template <typename... Is> struct Seq;
template <typename I, typename... Is>
struct Seq<I, Is...> {
 template <int n, typename Out> struct Result {
 typedef typename I::template Result<n, Out> A;
 typedef typename Seq<Is...>::template Result<Wrap<A::value>::value, typename A::Output> B;
 typedef typename B::Output Output;
 };
};
template <> struct Seq<> {
 template <int n, typename Out> struct Result {
 typedef Out Output;
 };
};
int main() {
 Seq<PROGRAM>::Result<0, Nil>::Output::print();
}
</nowiki>
== C++ Simplest ==
#include<iostream>
#include<cstdio>
#include<string>
#include<cstring>
using namespace std;
void deadfish(string com)
{
	long long acc = 0;
	for(int i=0;i<com.length();i++)
	{
		switch (com[i])
		{
			case 'i':
				acc++;
				break;
			case 'd':
				acc--;
				break;
			case 's':
				acc = acc * acc;
				break;
			case 'o':
				cout << acc << " ";
				break;
			case 'w':
				cout << char(acc);
				break;
			default:
				// Do nothing
				break;
		}
	}
}
int main()
{
	printf("Deadfish interpreter by PSTF\n");
	string a;
	while(1)
	{
		cout << ">>> ";
		cin >> a;
		if(a == "exit")
		{
			cout << "Thank you for using!";
			return 0;
		}
		else
		{
			deadfish(a);
			cout << "\n\n";
		}
	}
}
== Castile ==
Runs under (at least) Castile 0.3. Does not accept more than one command per line.
<nowiki>
fun main() {
 a = 0;
 c = "";
 while true {
 if a == 256 or a < 0 {
	a = 0;
 }
 c = input(">> ");
 if c == "i" {
 a = a + 1;
 } else if c == "d" {
 a = a - 1;
 } else if c == "s" {
 a = a * a;
 } else if c == "o" {
 print(str(a));
 }
 }
}
</nowiki>
== CLFCE ==
Technically this program is 9 lines long
 compile[1-10]
 a(0)
 loop(
 c(input(">"))
 if(c="i") then(a=a+1)
 elseif(c="d") then(a=a-1)
 elseif(c="s") then(a=a*a)
 elseif(c="o") then(therm(a))
 if(a=256) then(a=0)
 elseif(a=-1) then(a=0)
 )
== Chicken ==
<nowiki>
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken
chicken
chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken
chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken
chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken
chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken
chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken
chicken
chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken
chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken
chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken chicken
chicken chicken chicken
chicken chicken chicken chicken chicken chicken chicken chicken
</nowiki>
== C-INTERCAL ==
<nowiki>
PLEASE NOTE Written by oshaboy
DO ,1 <- #1024
DO WRITE IN ,1
DO .3 <- #0
PLEASE NOTE .20 is index
DO .20 <- #1
DO NOTE :10 is the accumulator
PLEASE :10 <- #0
DO COME FROM (40)
PLEASE NOTE Check if EOF
PLEASE .6 <- ',1 SUB .20'~#256
PLEASE ABSTAIN .6 FROM COMING FROM
(60) DO NOTHING
PLEASE (20) NEXT
DO COME FROM (60)
PLEASE REINSTATE COMING FROM
DO NOTE This loads the next char into .3
PLEASE REINSTATE NEXTING
DO .1 <- .3
DO .2 <- ,1 SUB .20
PLEASE (1009) NEXT
PLEASE NOTE This removes capitalization and makes the code MUCH shorter
DO .5 <- .3~#31
PLEASE ABSTAIN .5 FROM NEXTING
PLEASE (20) NEXT
DO REINSTATE NEXTING
DO (44) NEXT
DO REINSTATE NEXTING
DO (44) NEXT
DO REINSTATE NEXTING
DO (44) NEXT
DO REINSTATE NEXTING
PLEASE (31) NEXT
DO REINSTATE NEXTING
DO (44) NEXT
DO REINSTATE NEXTING
DO (44) NEXT
DO REINSTATE NEXTING
DO (44) NEXT
DO REINSTATE NEXTING
DO (44) NEXT
DO REINSTATE NEXTING
PLEASE (32) NEXT
DO REINSTATE NEXTING
DO (44) NEXT
DO REINSTATE NEXTING
DO (44) NEXT
DO REINSTATE NEXTING
DO (44) NEXT
DO REINSTATE NEXTING
DO (44) NEXT
DO REINSTATE NEXTING
DO (44) NEXT
DO REINSTATE NEXTING
PLEASE (33) NEXT
DO REINSTATE NEXTING
DO (44) NEXT
DO REINSTATE NEXTING
DO (44) NEXT
DO REINSTATE NEXTING
DO (44) NEXT
DO REINSTATE NEXTING
PLEASE (34) NEXT
DO REINSTATE NEXTING
DO (44) NEXT
DO REINSTATE NEXTING
DO (44) NEXT
DO REINSTATE NEXTING
DO (44) NEXT
DO REINSTATE NEXTING
DO (44) NEXT
DO REINSTATE NEXTING
DO (44) NEXT
DO REINSTATE NEXTING
DO (44) NEXT
DO REINSTATE NEXTING
DO (44) NEXT
DO REINSTATE NEXTING
DO (44) NEXT
DO REINSTATE NEXTING
DO (44) NEXT
DO REINSTATE NEXTING
DO (44) NEXT
DO REINSTATE NEXTING
DO (44) NEXT
DO REINSTATE NEXTING
DO (44) NEXT
DO REINSTATE NEXTING
DO (44) NEXT
DO COME FROM (51)
DO COME FROM (52)
DO COME FROM (53)
DO COME FROM (54)
(44) DO FORGET #1
DO .1 <- .20
PLEASE (1020) NEXT
PLEASE .20 <- .1
PLEASE NOTE Check if greater then[sic] 256
DO :1 <- :10
DO :1 <- :&1
DO :1 <- :&1
DO :1 <- :&1
DO :1 <- :&1
DO :1 <- :&1
DO :1 <- :&1
DO :1 <- :&1
DO :1 <- :&1
DO :1 <- :&1
DO :1 <- :&1
DO :1 <- :&1
DO :1 <- :&1
DO :1 <- :&1
DO :1 <- :&1
DO :1 <- :&1
DO :1 <- :&1
DO :1 <- :&1
DO :1 <- :&1
DO :1 <- :&1
DO :1 <- :&1
DO :1 <- :&1
DO :1 <- :&1
DO :1 <- :&1
DO :1 <- :&1
DO :1 <- :&1
DO :1 <- :&1
DO :1 <- :&1
DO :1 <- :&1
DO :1 <- :&1
DO :1 <- :&1
DO :1 <- :&1
DO :1 <- :&1
PLEASE :1 <- :1~#1
PLEASE ABSTAIN :1 FROM COMING FROM
(46) DO NOTHING
DO (35) NEXT
PLEASE REINSTATE COMING FROM
PLEASE COME FROM (46)
PLEASE :1 <- :10~#256
PLEASE ABSTAIN :1 FROM COMING FROM
(47) DO NOTHING
PLEASE REINSTATE COMING FROM
DO :1 <- :10~'#65535$#65519'
DO :1 <- :V1
DO :1 <- :V1
DO :1 <- :V1
DO :1 <- :V1
DO :1 <- :V1
DO :1 <- :V1
DO :1 <- :V1
DO :1 <- :V1
DO :1 <- :V1
DO :1 <- :V1
DO :1 <- :V1
DO :1 <- :V1
DO :1 <- :V1
DO :1 <- :V1
DO :1 <- :V1
DO :1 <- :V1
DO :1 <- :V1
DO :1 <- :V1
DO :1 <- :V1
DO :1 <- :V1
DO :1 <- :V1
DO :1 <- :V1
DO :1 <- :V1
DO :1 <- :V1
DO :1 <- :V1
DO :1 <- :V1
DO :1 <- :V1
DO :1 <- :V1
DO :1 <- :V1
DO :1 <- :V1
DO :1 <- :V1
PLEASE :1 <- :1~#1
PLEASE ABSTAIN :1 FROM NEXTING
PLEASE (35) NEXT
PLEASE REINSTATE NEXTING
PLEASE COME FROM (47)
(40) PLEASE DO NOTHING
(20) PLEASE GIVE UP
(31)
PLEASE :1 <- :10
PLEASE :2 <- #1
DO (1510) NEXT
(51) PLEASE :10 <- :3
(32)
PLEASE :1 <- :10
PLEASE :2 <- #1
DO (1509) NEXT
(52) PLEASE :10 <- :3
(33) PLEASE READ OUT :10
(53) DO NOTHING
(34)
PLEASE :1 <- :10
PLEASE :2 <- :10
DO (1549) NEXT
(54) PLEASE :10 <- :3
(35)
PLEASE :10 <- #0
PLEASE RESUME #1
</nowiki>
== Clever ==
 import std.io.* as io;
 Int a = 0;
 String c;
 while (true) {
 if (a < 0 || a == 256) {
 a = 0;
 }
 io::print(">> ");
 c = io::readln();
 if (c == "s") {
 a *= a;
 } else if (c == "i") {
 a += 1;
 } else if (c == "d") {
 a -= 1;
 } else if (c == "o") {
 io::print(a);
 io::print("\n");
 }
 }
== COBOL ==
 identification division.
 program-id. deadfish.
 data division.
 working-storage section.
 77 n usage binary-int unsigned.
 77 deadfish pic x.
 procedure division.
 perform forever
 call "printf" using z">> " end-call
 call "scanf" using z"%c" deadfish end-call
 if (n equal -1) or (n equal 256) then move 0 to n end-if
 evaluate deadfish
 when equal "d"
 subtract 1 from n giving n end-subtract
 when equal "i"
 add 1 to n giving n end-add
 when equal "o"
 call "printf" using x"25641000" by value n end-call
 when equal "s"
 multiply n by n end-multiply
 when equal "h"
 exit perform
 when other
 call "printf" using x"1000" end-call
 end-evaluate
 end-perform
 goback.
 end program deadfish.
== Commodore 64 BASIC ==
Type "H" to quit. (Fixed to comply with the Deadfish 0-255 rule (again (again))).
This program will also work in several other 8-bit BASICs, such as Applesoft BASIC.
10 INPUT A$
20 IF A$="I" THEN B = B+1
21 IF A$="D" THEN B = B-1
22 IF A$="S" THEN B = B*B
23 IF A$="O" THEN PRINT B
24 IF A$="H" THEN END
31 IF B = 256 THEN B = 0
32 IF B = -1 THEN B = 0
33 GOTO 10
== Common Lisp ==
Ensures full compliance, but throws an error when an invalid command is given.
;;; The deadfish macro expects a string as its argument.
(defparameter *acc* 0)
(defvar deadfish-dictionary '((#\i '1+)(#\d '1-)(#\s 'square)(#\o 'print)))
(defun square (x) (* x x))
(defun deadfish-limit (x) (if (or (< x 0) (eql x 256)) 0 x))
(defmacro deadfish (input)
 (setf *acc* 0)
 `(progn ,@(mapcar (lambda (ch) `(setf *acc* (deadfish-limit (funcall ,(cadr (assoc ch deadfish-dictionary)) *acc*))))
		 (coerce input 'list))
	 nil))
This version prompts the user for an input and responds to invalid characters with a newline.
 (let ((accumulator 0))
 (declare (type integer accumulator))
 (loop with input of-type (or null string) = NIL do
 (format T "~&>> ")
 (setf input (read-line))
 (clear-input)
 (when input
 (loop for token of-type character across input do
 (when (or (= accumulator -1) (= accumulator 256))
 (setf accumulator 0))
 (case token
 (#\i (incf accumulator))
 (#\d (decf accumulator))
 (#\o (write accumulator))
 (#\s (setf accumulator (* accumulator accumulator)))
 ((#\Newline #\Space #\Tab) NIL)
 (otherwise (terpri)))))))
== CraftyFunge ==
Video
Code
== Cthulhu ==
0A *]A
1A i
2A i[6A
3A e2AdE2A[6A
4A e2AE2BE4Be8AE3B[0B[6A
5A e2Ao[0A
6A e2Aiiiiiiii]A
7A E2A[0A
8A [0A
264A E2A[0A
265A [0A
0B e4B]C
0C e3BE2A
1C e4BdE4Be2BE5B[1B[0B
1B e5B]D
0D i
1D e5BdE5Be3BiE3B[1B
Note that since there is no character input in Cthulhu, input is supplied as numbers - 1 is end, 2 is i, 3 is d, 4 is s and 5 is o. 
== dc ==
 # Implements XKCD variation of Deadfish.
 [p]1:z[d*]2:z[1+]3:z[1-]4:z[0sB]dsAx[lB0>AlB256=A0d?lBz;zxsBclCx]dsCx
To use, enter each command in lower case on a line by itself.
This program uses the fact that in dc, each of "x", "k", "c", and "d" each do a different thing to a stack that has been pre-seeded with "0 0". The stack depth is then used to index an array of macros.
The "idso" version can't be done for that reason. "i" and "o" both consume a single positive integer off the top of the stack and error otherwise.
== Deadfish ==
A brief study of the Deadfish language should convince you that it is not possible to implement a Deadfish interpreter in it.
However, on August 4 2012, Chris Pressey took it upon himself to visit the Deadfish Cafe in Winnipeg, Manitoba and, while having coffee there, to implement Deadfish in Turing, in order to come as close as possible to "implementing Deadfish in Deadfish".
== Deadfish "self-interpreter" ==
This is very close to a Deadfish self-interpreter.
a:i:d:s:oj
== Deadfish++ ==
Please enter 1 character at a time. Supports both idso and xkcd. h to halt.
 [u~a;f(a=i):i;f(a=x):i;f(a=d):d;f(a=s):s;f(a=k):s;f(a=o):o;f(a=c):o;f(a=h):h;]
== Difficult ==
thing.keyword.while true[
	thing.keyword.if (n eq 256)or(n ls 0)[n=0?]
	n=thing.console.input(">> ")?
	thing.keyword.switch n[
		thing.keyword.wheneq "d"[
			n--?
		]
		thing.keyword.wheneq "i"[
			n++?
		]
		thing.keyword.wheneq "o"[
			thing.console.print("*(n)")?
		]
		thing.keyword.wheneq "s"[
			n=n^2?
		]
	]
]
== DL ==
Interprets a command per line.
 DL Start
 Var Integer @x
 Var String @cmd
 Var Bool @bool
 Var Integer @pos
 ParStr(@cmd)
 StrPos(@cmd,i,@pos)
 Cmp(@pos,0,@bool)
 IfNot(@bool)
 	Add(@x,1,@x)
 ###
 StrPos(@cmd,d,@pos)
 Cmp(@pos,0,@bool)
 IfNot(@bool)
 	Sub(@x,1,@x)
 ###
 StrPos(@cmd,s,@pos)
 Cmp(@pos,0,@bool)
 IfNot(@bool)
 	Mul(@x,@x,@x)
 ###
 StrPos(@cmd,o,@pos)
 Cmp(@pos,0,@bool)
 IfNot(@bool)
 	say @x
 	NL
 ###
 Cmp(@x,-1,@bool)
 If(@bool)
 @x = 0
 ###
 Cmp(@x,256,@bool)
 If(@bool)
 @x = 0
 ###
 Goto(6)
 DL End
== Drift ==
 filo cell.0
 fifo uin
 loop {
 if ?uin = 0 {
 print char '\n
 print char '>
 uin.sin
 }
 if ^cell = 256 | ^cell = (0-1) {
 ~cell
 cell.0
 }
 filo curr.(~uin)
 if ^curr = 'i {
 cell.(~cell+1)
 }else if ^curr = 'd {
 cell.(~cell-1)
 }else if ^curr = 's {
 cell.(^cell*~cell)
 }else if ^curr = 'o {
 print int ^cell
 } else {
 break
 }
 del curr
 }
== Easyfuck ==
This program takes in the code character by character and executes it after encountering a "carriage return" character:
i(#increment bi-cell
 +`(<+>)
 #check if number is 0b00000001 00000000 (256)
 -`(<--`(0-->0-<)++>)+
 #check if number is 0b11111111 11111111 (-1)
 <$>>!<$>&>0--------<[}`(>+<)]>-`(<<0<0>>>)0<0<<
)
d(#decrement bi-cell
 -`(<->)
 #check if number is 0b00000001 00000000 (256)
 -`(<--`(0-->0-<)++>)+
 #check if number is 0b11111111 11111111 (-1)
 <$>>!<$>&>--------<[}`(>+<)]>-`(0<0<0<0>>>)<<<
)
l(#left-rotate bi-cell
 <{>{`(<+>)
)
a(#add bi-cell to one to the left
 $0<<=`(<+>)>$0<<=>
)
o(#print int at bi-cell, then a space
 OS2.S
)
r(#copy bi-cell to the right
 <$>>!<$>>!
)
s(#square bi-cell
 r$<<M>$>Mlllllllla
 #check if number is 0b00000001 00000000 (256)
 -`(<--`(0-->0-<)++>)+
)
<>0>0>0>0>0>1---$0 #alloc memory and set storage to 13
>,.^[^>,.^]^---. #take input until 13 (enter on windows), then output new line
[#main loop
 J>>>>>>>>>>S0+S #go past memory and set storage to 1
 S[S>`X-``(S0S)+S]S$0J! #go through code until nonzero encountered, take to storage and turn into zero
 >^-`(>>>>>iJ$>)+^ #compare against i and if equal, increment
 >^-`(>>>>dJ$>>)+^ #compare against d and if equal, decrement
 >^-`(>>>sJ$>>>)+^ #compare against s and if equal, square
 >^-`(>>oJ$>>>>)+^ #compare against o and if equal, output
]
#structure: 0[stdin]1-4[chars i d s o]5-10[3 memory bi-cells]11+[deadfish program]
@ idso
Here is a minified version:
i(+`(<+>)-`(<--`(0-->0-<)++>)+<$>>!<$>&>
0--------<[}`(>+<)]>-`(<<0<0>>>)0<0<<)d(
-`(<->)-`(<--`(0-->0-<)++>)+<$>>!<$>&>--
------<[}`(>+<)]>-`(0<0<0<0>>>)<<<)l(<{>
{`(<+>))a($0<<=`(<+>)>$0<<=>)o(OS2.S)r(<
$>>!<$>>!)s(r$<<M>$>Mlllllllla-`(<--`(0-
->0-<)++>)+)<>0>0>0>0>0>1---$0>,.^[^>,.^
]^---.[J>>>>>>>>>>S0+SS[S>`X-``(S0S)+S]S
$0J!>^-`(>>>>>iJ$>)+^>^-`(>>>>dJ$>>)+^>^
-`(>>>sJ$>>>)+^>^-`(>>oJ$>>>>)+^]@ idso
== eWagon2 ==
Neat:
 Enter your program as one line
 " >>"^^^!!!? "h" '0'
 {~
 "i"^%=^ [`^'1'^+]
 "d"^%=^ [`^'1'^-]
 "s"^%=^ [`%^*]
 "o"^%=^ [`%$]
 "h"^%=^ [.]
 ` '256'^%=^ [,'0']
 '-1'^%=^ [,'0']
 ~ , '1'^ }
Compact:
 " >>"^^^!!!?"h"'0'{~"i"^%=^[`^'1'^+]"d"^%=^[`^'1'^-]"s"^%=^[`%^*]"o"^%=^[`%$]"h"^%=^[.]`'256'^%=^[,'0']'-1'^%=^[,'0']~,'1'^}
== Exechars ==
With the Original implementation, you need to enter the ASCII value of the letters (in decimal), separated by commas.
 (64-0)(69+0)(6fn0)(73r0v+5-5r0v+6r5v/2r5v-5r6v-6)(2r6v+0)(0i2?2=at0/2v?0=3/1?0=4+0/0)(1r100-0)r100+3-4rffff+a+0-0/0t
== Execode ==
With the Original implementation, you need to enter the ASCII value of the letters, separated by commas.
 def var 0
 def var 1
 def var 2
 def stk 0
 def fnc 105
 inc 0
 end
 def fnc 100
 dec 0
 end
 def fnc 111
 out 0
 end
 def fnc 115
 psh 0 to 0
 pop 0 to 2
 psh 2 to 0
 dec 2
 con 2
 cll 10
 end
 def var 10
 def fnc 0
 pop 0 to 1
 psh 1 to 0
 cll 11
 dec 2
 con 2
 cll 10
 end
 def var 11
 inc 11
 def fnc 1
 inc 0
 dec 1
 con 1
 cll 11
 end
 def var 12
 inc 12 rpt 2
 def fnc 2
 inp 20
 cll 20
 con 0 eq 256
 def var 0
 con 0 eq -1
 def var 0
 cll 12
 end
 def var 20
 def var 256
 inc 256 rpt 256
 def var -1
 dec -1
 cll 12
 ter
== Falcon ==
no=0
loop
 if no==-1 or no==256
 no=0
 end
 >> ">> "
 the_cmd = input()
 switch the_cmd
 case "d"
 no=no-1
 case "i"
 no=no+1
 case "o"
 > no
 case "s"
 no=no*no
 end
end
== FALSE ==
 [0~]["
 >> "^
 \$\$256=\1_=&[%0]?\
 $'i=[\1+\]?
 $'d=[\1-\]?
 $'s=[\$*\]?
 'o=[$,]?
 ]#
== Felix ==
 include "std/textio";
 open Text_file;
 var a : int;
 while {true}
 {
 write(stdout, ">> ");
 a = if a == 256 or a < 0 then 0 else a;
 match readln stdin with
 | "i\n" => { ++a; }
 | "d\n" => { --a; }
 | "s\n" => { a*=a; }
 | "o\n" => { print a; endl; }
 endmatch;
 };
== ><> ==
This is the actual idso version, with the correct x==-1||x==256 behaviour.
 v Load zero in the register
 \0&
 v <
 
 \" >>"ooo
 v < The input loop, stopping on 13 (CR, enter press)
 \i:o
 \:d=?!^~aor
 We process in reverse order, that's why the 'r'
 v <
 \&::&01-=$f1+:*=+?v
 v &0~&< The x==0||x==256 -> x=0 thing
 \l0=?v
 >ao ^ If done with input, output newline and return to input loop
 \:"i"=?v
 >~&1+& ^ Increment
 \:"d"=?v
 >~&1-& ^ Decrement
 \:"s"=?v
 >~&:*& ^ Square
 \:"o"=?v
 >~&:n& ^ Output
 \:"h"=?v
 >~; (^) HALT
 >~ ^ If none of those, just remove it from input and run next
== Fishing ==
v+CC[vCCCCCCCC?!CCCCCCCCCC?!CCCCCCCCCCCCCCCCC?!CCCCCC?!CCCCCC?!CCCCCC?!CCCCCCD_
 n{D E`-1`n} = {E`256`n} = { E`>>`PEI{E`i`}= {E`d`}= {E`s`}= {E`o`}= {{N}} D
 D _DDDDDDDDDDD] D D D D D 
 D < D D D D D
 D D < < < < D
 D EC }C }C }C }C D
 D `C iC dC SC NC D
 D 0C {C {C {C {C D
 D `C D D D D D
 D nC D D D D D
 D {C D D D D D 
 |DDDDDDDDD]DDDDDDDDDDDDDDDDDDDDDDDDDDDDDD]DDDDDDD]DDDDDDD]DDDDDDD]DDDDDDDD]
==FlinnScrip==
while(0=nil){
input(1);//this does not output ">>" because flinnscript does not support prepends and appends in inputs.
if(1="i"||1="x"){add(2,1);};
if(1="d"){add(2,-1);};
if(1="s"||1="k"){multiply(2,var(2));};
if(1="o"||1="c"){print(2);};
if(2=256||2=-1){set(2,0);};
};
== Forobj ==
 ">> "d'>i[,n>c[$i'1+>i][[$i'1->i][[$i,*>i][[$i d"\n"d][">> "d]$c"o"=?]$c"s"=?]$c"d"=?]$c"i"=?['>i][]$i'256=$i'=|?\],._
== Forth ==
 \ Type 'h' to halt
 : MAIN
 0 BEGIN
 DUP 256 = OVER -1 = OR IF DROP 0 THEN
 KEY CASE
 'i' OF 1+ ENDOF
 'd' OF 1- ENDOF
 's' OF DUP * ENDOF
 'o' OF DUP . ENDOF
 'h' OF DROP EXIT ENDOF
 ENDCASE
 AGAIN
 ;
 MAIN BYE
== FORTRAN 77 ==
c Deadfish interpreter in FORTRAN 77
 PROGRAM DEADFISH
 CHARACTER*1 inp
 INTEGER state
 state = 0
 DO
 WRITE(*,'(2A)', ADVANCE='no')">>"
 READ(*,*)inp
 IF (state .EQ. 256 .OR. state .LT. 0)
 + state = 0
 IF (inp .EQ. 'i') THEN
 state = state + 1
 ELSE IF (inp .EQ. 'd') THEN
 state = state - 1
 ELSE IF (inp .eq. 's') THEN
 state = state**2
 ELSE IF (inp .EQ. 'o') THEN
 WRITE(*,"(I3)")state
 END IF
 END DO
 END
== Free Hero Mesh ==
<nowiki>
; Of course, it is not possible to win this game.
(Control Player Input
 ('I %x 1 + =%x)
 ('D %x 1 - =%x)
 ('S %x %x * =%x)
 ('O %x PopUp)
 (BEGIN_TURN %x -1 eq %x 256 eq lor if 0 =%x then)
)
</nowiki>
== Fueue ==
This hits some bugs in all the known Fueue interpreters. Join it into a single line to run it in the C one.
<nowiki>
[0]):[
 )$$17--1[)$5~[)~[0]])$[[)[~~~~()+1])])]<<<[[
 )~<[)$%+-~)~~~100[)[
 )~+[~:~~~)(]-1)
 ]!]~][
 )~<[)$%+-~)~~~105[)[
 )~+[~:~~~)(]%0)
 ]!]~][
 )~<[)$%+-~)~~~111[)[
 ):[)$$7--1[
 )$3~[)$~!~~%~)]$2<[):]~:
 ]~)~~[
 )~~~[~)~$7~~:~~([$3~)+[~~~<~()+48]~~~-)~10*)]/]--10):
 ]]
 ~[10 ~:)~]~: 
 ]!]~][
 )~<[)$%+-~)~~~115[)[
 )~*~~:[~:~~~)(])
 ]!]~][)[
 10 ~:)~
 ]!]:]:]:]:
 ]]]
 62 62 32 )~<~[
 )$%+%~)~~~0[[0]!]~
 ]~:[)~([
 )$%+-~)~~~256[[0]!]~
 ]:]~
]
</nowiki>
== Office VBA ==
Sub Deadfish()
 Dim Code As String
 Dim i As Integer
 Dim v As String
 Dim Accumulator As Integer
 Code = InputBox("Deadfish code?", "Deadfish")
 Accumulator = 0
 
 For i = 1 To Len(Code)
 v = Mid(Code, i, 1)
 Select Case v
 Case "i"
 Accumulator = Accumulator + 1
 Case "d"
 Accumulator = Accumulator - 1
 Case "s"
 Accumulator = Accumulator * Accumulator
 Case "o"
 MsgBox (Accumulator)
 End Select
 
 If Accumulator = 256 Or Accumulator = -1 Then
 Accumulator = 0
 End If
 Next
End Sub
==G#==
 ticker assign a as 0
 boolean assign l as 1
 make main; [
 print("Deag#ish",\n)
 loop if ?l is 1 [
 for c in input [
 if c is "i" [add 1 to +a]
 orif c is "d" [add -1 to +a]
 orif c is "s" [add +a to +a]
 orif c is "o" [print(+a)]
 ]
 ]
 ]
== gar ==
>
<
+
^
{
??
>>>>>>>>>>
:
*
|
+
]
~
)
[
<<<<<
+
]]
~
))
[[
<<<<<<
+
]]]
~
)))
[[[
<<<<
+
]]]]
~
))))
[[[[
~~
)))))
(
~~
^^
<
+
^
~~
)))))
((
~~
^^
>
+
^
~~
)))))
(((
~~
^^
!
}
((((
~~
^^
:
*
^
~
(((((
~~
>
^^
+
]]]]]
>
<
+
^
[[[[[
~~
>>>>
:
:
:
*
*
*
|
^^
+
]]]]]]
>
<
+
^
[[[[[[
~~
}
== Glass ==
{M[moO!iI!aA!sS!n<0>=c<1>=/cc<1>ie.?as.?=ec*=/e">> "oo.?fil.?=gf
*sl.?=hg*=l<-1>n*ae.?<256>n*ae.?aa.?=/ln<0>=l<0>=\/hjf*g*h*as.?s
i.?=kj*"i"se.?=/knn*<1>aa.?=k<0>=\kj*"d"se.?=/knn*<1>as.?=k<0>=\
kj*"s"se.?=/knn*n*am.?=k<0>=\kj*"o"se.?=/kn*o(on).?<10>s(ns).?oo
.?k<0>=\hh*<1>as.?=\e<0>=\\<10>s(ns).?oo.?]}
== Glulx ==
	<!include ":glulx"
	<!include ":glk"
	!stack 256
:Prompt	!string ">> "
	!main 3
	; Check if Glk supported; quit if not
	gestalt gs.IOSystem,2,$
	jz $,0
	; Open window
	!pushr 0,0,0,glk.wintype_TextBuffer,0
	glk glk_window_open,5,$2
	jz $2,0
	push $2
	glk glk_set_window,1,0
	setiosys 2,0
	; Main loop
	; Check if number is -1 or 256
0h	jne $0,-1,1f
2h	copy 0,$0
1h	jeq $0,256,2b
	; Prompt and get input
	streamstr Prompt
	!pushr $2,Buf,1,0
	glk glk_request_line_event,4,0
1h	push Event
	glk glk_select,1,0
	jne @Etype,glk.evtype_LineInput,1b
	jz @Eval1,0b
	; Execute operation
	copyb @Buf,$1
	jeq $1,'i',I
	jeq $1,'d',D
	jeq $1,'s',S
	jeq $1,'o',O
	jump 0b
	; Increment
:I	add $0,1,$0
	jump 0b
	; Decrement
:D	sub $0,1,$0
	jump 0b
	; Square
:S	mul $0,$0,$0
	jump 0b
	; Output
:O	streamnum $0
	streamchar 10
	jump 0b
	!bss
:Event	!allot 16
:Etype	!is Event
:Ewin	!is Event+4
:Eval1	!is Event+8
:Eval2	!is Event+12
:Buf	!allot 8
== Go ==
package main
import (
	"os"
	"fmt"
	"bufio"
)
func main() {
	reader := bufio.NewReader(os.Stdin)
	var x int
	for {
		fmt.Print(">> ")
		input, err := reader.ReadString('\n')
		if err != nil {
			return
		}
		for _, c := range input {
			switch c {
			case 's':
				x = x * x
			case 'i':
				x++
			case 'd':
				x--
			case 'o':
				fmt.Println(x)
			}
			if x < 0 || x == 256 {
				x = 0
			}
		}
	}
}
== GotoScript ==
 # Variables
 1 x := 0
 2 new_x := ""
 
 # Reset accumulator on under/overflow
 3 GOTO 1 IF x < 0 | x = 256
 
 # Get input
 4 GOTO INPUT '>> ' CATCH 5
 
 # Invalid input
 5 PRINT 'Invalid command.'
 
 # Increment
 'i' new_x := x + 1
 
 # Decrement
 'd' new_x := x - 1
 
 # Square
 's' new_x := x * x
 
 # Output
 'o' PRINT x
 6 GOTO 4
 
 # Loop back
 7 GOTO 2 WHEN new_x != ""
== Gray Snail ==
Instead of squaring numbers above 31, it just returns 0. Instead of increasing above 999, it goes to 0. However, you can reach 999, as 999 is regarded as separate from -1 (it checks whether 999 was obtained by increment or decrement).
POP a number a000
POP a "show number" a
POP a carry a0
POP a newline a"
"
POP a "all input" a">>"
"input more commands"
OUTPUT "[all input]"
INPUT commands
"analyse commands"
OUTPUT "[all input]"
POP instruction commands [commands]
GOTO "input more commands" [instruction] ""
POP a temp a[number]
POP hundreds temp [temp]
POP tens temp [temp]
POP ones temp [temp]
GOTO "o command" [instruction] o
GOTO "s command" [instruction] s
GOTO "di command" [instruction] d
GOTO "di command" [instruction] i
POP a "all input" a"[all input][instruction][newline]>>"
GOTO "analyse commands"
"o command"
GOTO "skip hundreds" [hundreds] 0
POP a "all input" a"[all input]o[newline][number][newline]>>"
GOTO "analyse commands"
"skip hundreds"
GOTO "skip tens" [tens] 0
POP a "all input" a"[all input]o[newline][tens][ones][newline]>>"
GOTO "analyse commands"
"skip tens"
POP a "all input" a"[all input]o[newline][ones][newline]>>"
GOTO "analyse commands"
"s command"
POP a "all input" a"[all input]s[newline]>>"
GOTO "square 0[ones]" [number] 00[ones]
GOTO "square 1[ones]" [number] 01[ones]
GOTO "square 2[ones]" [number] 02[ones]
GOTO "square 30" [number] 030
GOTO "square 31" [number] 031
GOTO "to 000"
"di command"
POP a "all input" a"[all input][instruction][newline]>>"
POP a digit aones
GOTO "[instruction] [ones]"
"finished with one operation"
GOTO "completely finished" [carry] 0
GOTO "completely finished" [digit] hundreds
"#This is in case we have just changed tens, so we have to change hundreds."
GOTO "digit is tens" [digit] tens
POP a digit atens
GOTO "[instruction] [tens]"
"digit is tens"
POP a digit ahundreds
GOTO "[instruction] [hundreds]"
"completely finished"
GOTO "to 000" [hundreds][tens][ones] 256
GOTO "to 000" [instruction][hundreds][tens][ones] d999
POP a number a[hundreds][tens][ones]
"number is changed"
POP a carry a0
GOTO "analyse commands"
"to 000"
POP a number a000
GOTO "number is changed"
"d 0"
POP a [digit] a9
POP a carry a1
GOTO "finished with one operation"
"d 1"
POP a [digit] a0
POP a carry a0
GOTO "finished with one operation"
"d 2"
POP a [digit] a1
POP a carry a0
GOTO "finished with one operation"
"d 3"
POP a [digit] a2
POP a carry a0
GOTO "finished with one operation"
"d 4"
POP a [digit] a3
POP a carry a0
GOTO "finished with one operation"
"d 5"
POP a [digit] a4
POP a carry a0
GOTO "finished with one operation"
"d 6"
POP a [digit] a5
POP a carry a0
GOTO "finished with one operation"
"d 7"
POP a [digit] a6
POP a carry a0
GOTO "finished with one operation"
"d 8"
POP a [digit] a7
POP a carry a0
GOTO "finished with one operation"
"d 9"
POP a [digit] a8
POP a carry a0
GOTO "finished with one operation"
"i 0"
POP a [digit] a1
POP a carry a0
GOTO "finished with one operation"
"i 1"
POP a [digit] a2
POP a carry a0
GOTO "finished with one operation"
"i 2"
POP a [digit] a3
POP a carry a0
GOTO "finished with one operation"
"i 3"
POP a [digit] a4
POP a carry a0
GOTO "finished with one operation"
"i 4"
POP a [digit] a5
POP a carry a0
GOTO "finished with one operation"
"i 5"
POP a [digit] a6
POP a carry a0
GOTO "finished with one operation"
"i 6"
POP a [digit] a7
POP a carry a0
GOTO "finished with one operation"
"i 7"
POP a [digit] a8
POP a carry a0
GOTO "finished with one operation"
"i 8"
POP a [digit] a9
POP a carry a0
GOTO "finished with one operation"
"i 9"
POP a [digit] a0
POP a carry a1
GOTO "finished with one operation"
"square 00"
POP a number a000
GOTO "analyse commands"
"square 01"
POP a number a001
GOTO "analyse commands"
"square 02"
POP a number a004
GOTO "analyse commands"
"square 03"
POP a number a009
GOTO "analyse commands"
"square 04"
POP a number a016
GOTO "analyse commands"
"square 05"
POP a number a025
GOTO "analyse commands"
"square 06"
POP a number a036
GOTO "analyse commands"
"square 07"
POP a number a049
GOTO "analyse commands"
"square 08"
POP a number a064
GOTO "analyse commands"
"square 09"
POP a number a081
GOTO "analyse commands"
"square 10"
POP a number a100
GOTO "analyse commands"
"square 11"
POP a number a121
GOTO "analyse commands"
"square 12"
POP a number a144
GOTO "analyse commands"
"square 13"
POP a number a169
GOTO "analyse commands"
"square 14"
POP a number a196
GOTO "analyse commands"
"square 15"
POP a number a225
GOTO "analyse commands"
"square 16"
GOTO "to 000"
"square 17"
POP a number a289
GOTO "analyse commands"
"square 18"
POP a number a324
GOTO "analyse commands"
"square 19"
POP a number a361
GOTO "analyse commands"
"square 20"
POP a number a400
GOTO "analyse commands"
"square 21"
POP a number a441
GOTO "analyse commands"
"square 22"
POP a number a484
GOTO "analyse commands"
"square 23"
POP a number a529
GOTO "analyse commands"
"square 24"
POP a number a576
GOTO "analyse commands"
"square 25"
POP a number a625
GOTO "analyse commands"
"square 26"
POP a number a676
GOTO "analyse commands"
"square 27"
POP a number a729
GOTO "analyse commands"
"square 28"
POP a number a784
GOTO "analyse commands"
"square 29"
POP a number a841
GOTO "analyse commands"
"square 30"
POP a number a900
GOTO "analyse commands"
"square 31"
POP a number a961
GOTO "analyse commands"
end
== Haskell ==
import Data.Int (Int32)
main = loop (0, "")
loop :: (Int32, String) -> IO ()
loop (x', s) = do
 putStr $ s ++ ">> "
 c <- getChar
 let x = case x' of -1 -> 0; 256 -> 0; _ -> x'
 loop $ case c of
 'i' -> (x+1, "")
 'd' -> (x-1, "")
 'o' -> (x, show x ++ "\n")
 's' -> (x*x, "")
 _ -> (x, "\n")
== Hot Soup Processor ==
; Deadfish in Hot Soup Processor (ver3.51), version 1 -- dnm 2021-06-04
accumulator = 0
command = ""
exitbtn="EXIT"
onexit goto *exit
onkey goto *interpret
objsize 600,24
mes "Deadfish Interpreter"
mes "Enter command:"
input command
button exitbtn,*exit
*loopreset
	stop
*interpret
	if accumulator = 256 | accumulator < 0 : accumulator = 0
	if iparam=73 : accumulator = accumulator + 1
	if iparam=68 : accumulator = accumulator - 1
	if iparam=83 : accumulator = accumulator * accumulator
	if iparam=79 : mes accumulator
	goto *loopreset
*exit
	end
== hsifdaeD ==
 ,idso
This terminates when you enter something that is not i, d, s or o.
== HTML / Javascript ==
This interpreter is .
<nowiki>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
 "http://www.w3.org/TR/html4/loose.dtd">
<HTML><HEAD><TITLE>Deadfish in HTML</TITLE>
<SCRIPT type="text/javascript">
var i=0;
function deadfish()
{
 var c=document.getElementById("cmd").value;
 document.getElementById("cmd").value="";
 document.getElementById('op').innerHTML+=
 "&gt;&gt;&nbsp;&#"+c.charCodeAt(0)+";<BR/>";
 if(c=='i') i++;
 else if(c=='d') i--;
 else if(c=='s') i*=i;
 else if(c=='o') document.getElementById('op').innerHTML+=i+"<BR/>";
 else document.getElementById('op').innerHTML+="<BR/>";
 if(i==256||i==-1) i=0;
 return false;
}
</SCRIPT>
</HEAD><BODY>
<H1>Deadfish in HTML</H1>
<DIV id="op"></DIV>
<FORM onsubmit="return deadfish()">
&gt;&gt;&nbsp;<INPUT type="text" maxlength="1" size="1" id="cmd" /><BR/>
<INPUT type="submit" value="Submit" />
</FORM>
</BODY></HTML>
</nowiki>
Another one:
<nowiki>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
 <head><title>Deadfish in HTML</title></head>
 <body>
 <a href="http://esolangs.org/wiki/Deadfish"<a>Deadfish in HTML</a>
 >> 
 <input id="cmd" type="text" onkeypress="if(event.charCode==13) deadfish();"/>
 <script type="text/javascript">
 var acc = 0;
 function deadfish(){
 var cmd=document.getElementById('cmd').value;
 if(cmd=='i') acc++;
 if(cmd=='d') acc--;
 if(cmd=='s') acc *= acc;
 if(acc==256 || acc<0) acc=0;
 if(cmd=='o') cmd+=''+acc;
 
 document.getElementById('out').innerHTML+=cmd+'>> ';
 document.getElementById('cmd').value=;
 }
 </script>
 </body>
</html>
</nowiki>
A shorter(and programmer friendly)one(I made it print every value after entering every command just for easier debugging).
<input id="cmd" type="text" onkeypress="d();"/>
<script>var a=0;
function d(){
 var c=document.getElementById('cmd').value;
 if(c=='i')a++;
 if(c=='d')a--;
 if(c=='s')a*=a;
 c+=' key pressed, the accumulator becomes '+a;
 if(a==256||a<0)a=0;
 document.getElementById('out').innerHTML+=c+'. ';
 document.getElementById('cmd').value=;
}</script>
== Html/Javascript Simplified ==
<!DOCTYPE html>
<html>
<head><title>Deadfish Interpreter</title></head>
<body>
<script>
var acc = 0;
do {
var a = prompt(">> ");
 if(a=='i') acc++;
 
 if(a=='d') acc--;
 
 if(a=='s') acc *= acc;
 
 if(a=='o') console.log(acc); 
 if(acc<0||acc==256) acc = 0;
 
} while(a!='h');
</script>
</body> 
</html>
== ICI ==
Quick and dirty, has an obvious bug I need to fix...
// Deadfish in ICI (4.1.0), version 1 -- dnm 2022-02-17
static accumulator = 0;
// BUG: each trip through the loop, e.g., via (each) break, prints anew (">> ")
// i.e., n command(s) submitted per line will print n prompt(s)
// Hitting ENTER at a prompt (i.e., no [other] input) will print just one ">> "
while (1) {
 if (accumulator == 256 || accumulator < 0) { accumulator = 0; }
 printf(">> "); 
 command := getchar();
 switch (command) {
 case "i": ++accumulator; break;
 case "d": --accumulator; break;
 case "s": accumulator = accumulator * accumulator; break;
 case "o": printf("%i\n", accumulator); break;
 }
}
== Io ==
This implementation uses Io REPL itself (so you have the powers of Io at your disposal). Should be either entered into REPL directly or with -i option.
<nowiki>
CLI setPrompt(">> ")
CLI writeCommandResult = false
x := 0
check := method(if(x == -1 or x == 256, x = 0))
i := method(check x = x + 1)
d := method(check x = x - 1)
s := method(check x = x * x)
o := method(x println)
</nowiki>
== itflabtijtslwi ==
Another implementation using a unary representation. On the machine I tested it with, it did not manage to print numbers much larger than 1000 in the time I had patience to wait.
/ / //
 //
 /*/()()()()()()()()()()()()()()()()/
 /./<\\\\>\\\\\\/
 /P1/
 >> 
 GGC.0GG
 ./N.a****************N.b./N.aN.b./
 ./C.a.\.\iC.b./
 .\./N.a.\./.\.\.\./N.\0.\.\.\./.\./
 .\./N.b.\./().\.\.\./.\./
 ./
 ./C.a.\.\dC.b./
 .\./N.a.\./.\.\.\./N.\0.\.\.\./.\./
 .\./()N.b.\./.\.\.\./.\./
 .\./N.b.\./.\.\.\./.\./
 ./
 ./C.a.\.\oC.b./
 .\./N.a.\./.\.\.\./N.\1.\.\.\./.\./
 .\./N.b.\./.\.\.\./
 .\.\.\./N.\d().\.\.\./N.\d1N.\d.\.\.\./
 .\.\.\./1N.\d.\.\.\./N.\d1.\.\.\./
 .\.\.\./N.\d1.\1.\1.\1.\1.\1.\1.\1.\1.\1.\.\.\./
 1.\.\.\.\N.\d
 .\.\.\./
 .\.\.\./N.\cN.\d.\.\.\./N.\c.\.\.\./
 .\.\.\./N.\c.\.\.\./N.\d.\.\.\./
 .\.\.\./N.\e.\.\.\./N.\d.\.\.\./
 .\.\.\./1.\1.\.\.\./2.\.\.\./.\.\.\./2.\1.\.\.\./3.\.\.\./
 .\.\.\./2.\2.\.\.\./4.\.\.\./.\.\.\./2.\3.\.\.\./5.\.\.\./
 .\.\.\./4.\2.\.\.\./6.\.\.\./.\.\.\./4.\3.\.\.\./7.\.\.\./
 .\.\.\./4.\4.\.\.\./8.\.\.\./.\.\.\./4.\5.\.\.\./9.\.\.\./
 .\.\.\./N.\dN.\d.\.\.\./0N.\d.\.\.\./
 .\.\.\./N.\d.\.\.\./.\.\.\./
 N.\cN.\dN.\1N.\e
 .\.\.\./N.\0.\.\.\./N.\1.\.\.\./
 .\./
 ./
 ./C.a.\.\sC.b./
 .\./N.a.\./.\.\.\./N.\1.\.\.\./.\./
 .\./N.b.\./.\.\.\./
 .\.\.\./N.\c().\.\.\./N.\1N.\c.\.\.\./
 .\.\.\./N.\c.\.\.\./.\.\.\./
 .\.\.\./N.\0.\.\.\./N.\cN.\1.\.\.\./
 .\./
 ./
 ./C.a./.\./W.b.\././
 ./C.b./.\./
 .\./N.a.\./.\.\.\./N.\0.\.\.\./.\./
 .\./N.b.\./.\.\.\./.\./
 ./
 C.a.\C.0C.b
 ./<.\>./<.\.\.\.\>.\.\.\.\.\.\./
 ./P.1./P.2./
 ./P.0./P.1./
 ./<.\>././
 ./P.\2./P.1./
 N.aN.0N.b
 P.0
 /
 /P0/P1/
 /<\>//
 /P2/P1/
 /N0//
 P0
== ΙΧΘΥΣ ==
Non-Latin Deadfish superset that can redefine itself to `idso` Deadfish
 ΙiιΘΙdχΘΙsθΘΙoυΘΧ
== J ==
This is a serious language that gets used in the finance industry, believe it or not. 
getchar =: 'libc.so.6 getchar >c'&cd
bounds =: (]*>&0*~:&256)@]
prompt =: ][1!:2&4&'>> '@1:
cmds =: 'idso', LF, 255{a.
cmdfns =: (>:@])`(<:@])`(*:@])`(][echo@])`prompt`(exit@0:)
loop =: getchar&@1:$:bounds@(cmdfns`]@.(cmds&i.@[))
LF loop 0
Here is a one line "incantation" by User:BoundedBeans. In J, one line is one expression, so everything here is in one expression as well. You can get past that limitation by using the LF constant inside of an explicit verb (or using control words inside of one), but I explicitly avoided this (although I did use explicit definitions as verbs). Originally this was going to be a script, but I also thought I wanted to remove all whitespace, and specifically one verb : doesn't work if you remove the whitespace around it (and a ton of other methods failed as well). What I settled on was dynamically loading the script from a string which all question marks are replaced with spaces, but none occur literally. To run this, either you can type it into the J shell, or it sort of works on tio.run (example here). Either way, you'll have to run Deadfish 0 after you run the incantation (it merely loads the Deadfish function; immediately calling it in the same line doesn't work for some reason).
It only accepts one command per line, and will crash if you try entering more, none, or any invalid command.
Anyway, here is the program:
<nowiki>
(0!:101)((u:11$32)((11,17,47,62,95,131,155,183,208,245,301)})'Deadfish=:3?:((3?:''(((256=0{y)+.(_1=0{y)){((3?:'''y''')`(3?:'''0(0})y''')))(`:6)y')&:((3?:'((('''idsoh'''i.((1!:1)1)){((3?:'''(1+0{y)0}y''')`(3?:'''y(0})~(_1+0{y)''')`(3?:'''y(0})~*:0{y''')`(3?:'''>(1{((":0{y)(1!:2)2);y)''')`(3?:'''y(1})~(_1+1{y)''')))(`:6))(y(1})~(1+1{y))')&:((3?:'>1{(('''>>'''(1!:2)2);y)')))^:_)0,0)
</nowiki>
== Java ==
// Deadfish in Java -- JTS
// Compiled with JDK 6 and tested with JRE 6 on Ubuntu 9.0.4
// And yes, I do hate Java like most people, and I hate how I have to do it for comp sci!
import java.util.Scanner;
public class Deadfish
{
	public static void main(String args[])
	{
		Scanner comm = new Scanner(System.in);
		boolean isSquared = false;
		int x = 0;
		String usrinput;
		while(true)
		{
			System.out.print(">> ");
			usrinput = comm.next();
			if(usrinput.contentEquals("i"))
			{
				if(x >= 256 && isSquared == false)
					x = 0;
				x++;
			}
			else if(usrinput.contentEquals("d"))
			{
				if(x <= -1 && isSquared == false)
					x = 0;
				x--;
			}
			else if(usrinput.contentEquals("o"))
				System.out.println(x);
			else if(usrinput.contentEquals("s"))
			{
				if(x >= 256)
					isSquared = true;
				x = x * x;
			}
			else
				System.out.println();
		}
	}
}
//FIN
Another one, compiling on JDK1.1
import java.io.*;
public class Deadfish {
 public static void main(String[] args) throws IOException { new Deadfish(); }
 public Deadfish() throws IOException {
 BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
 int acc = 0;
 for(char ch=0; ch!='h'; ch = in.readLine().charAt(0)){
 if(ch=='i') acc++;
 if(ch=='d') acc--;
 if(ch=='s') acc*=acc;
 if(acc==256 | acc<0) acc=0;
 if(ch=='o') System.out.println(acc);
 System.out.print(">> ");
 }
 }
}
Yet another one, now in JDK 11
import java.util.Scanner;
public class Deadfish{
 public static void main(String[] args){
 int x = 0;
 String code;
 while(true){
 System.out.print("\n>> ");
 code = input.nextLine();
 for(int i = 0; i < code.length; ++i){
 if(x == -1 || x == 256) x = 0;
 switch(code.charAt(i)){
 case 'i': ++x; break;
 case 'd': --x; break;
 case 's': x *= x; break;
 case 'o': System.out.print("\n"+x); break;
 case 'h': return;
 }
 }
 }
 }
}
Might as well add another one to the mix
import java.util.Scanner;
public class Main {
	public static void main(String[] args) {
		int acc = 0;
		Scanner input = new Scanner(System.in);
		String program = input.nextLine();
		
		for (char command : program.toCharArray()) {
			if (acc == -1 || acc == 256) { acc = 0;}
			switch (command) {
				case 'i': acc++; break;
				case 'd': acc--; break;
				case 's': acc *= acc; break;
				case 'o': System.out.print(acc); break;
			}
		}
	}
}
== JavaScript ==
Exports a function, import it with
import { deadfish } from "./path/to/deadfish.js"
and use it with
deadfish(/*code string/*, /*ascii output (boolean)*/)
export function deadfish (code, ascii) {
	let a = 0
	let x = []
	if (typeof(code) === "string") {
		let c = code.split("")
		for (let i = 0; i < code.length; i++) {
			switch (c[i]) {
				case 'i':
					a++
					break
				case 'd':
					a--
					break
				case 's':
					a *= a
					break
				case 'o':
					x.push(a)
					break
				default:
					break
			}
			if (a == 256 || a < 0) {
				a = 0
			}
		}
	}
	if (ascii === true) {
		return String.fromCharCode.apply(null, x)
	} else {
		return x
	}
}
== JavaScript (very short) ==
A very concise JS implementation by User:Nomad. I believe it is fully compliant.
(Had a fun time golfing to achieve this - JS has some pretty crazy quirks)
Save in a file, and call with deadfish code as command line parameter:
Ex: node interpreter.js iissso
(c => [0,...c.split()].forEach((v,i,a) => 
 i < 1 ? null : ((a[0] = a[0] === 256 || a[0] === -1 ? 0 : a[0]), 
 a[0] += (v === 'i' ? 1 : v === 'd' ? -1 : v === 's' ? (a[0]**2)-a[0] :
 (0, console.log(v === 'o' ? a[0] : ))))
))(process.argv.slice(2)[0] || )
Here is an even more concise implementation in JS from Blair Myhre that does not use NodeJS, and can be used across all forms of JS:
(s=>{var a=0;for(c of s){c=='d'?a--:c=='i'?a++:c=='s'?a=a**2:c=='o'?console.log(a):a=a}})(dfish)
Note that dfish can be defined as a string, or a DOM element, or anything you put your mind to...
let dfish = document.getElementById('textinput').value
== JSFuck ==
The JScrewIt conversion of the compact JavaScript interpreter is ridiculously long (25106 bytes), so LZMA is used to compress it into only 828 bytes. As such, you get a Python program that prints the original program:
print(__import__('lzma').decompress(__import__('base64').b64decode('/Td6WFoAAATm1rRGAgAhARYAAAB0L+Wj4GIRAvpdAC2XR6W7ezTpsthqBJMKlkHoj8hJp+R43Focgp9KAYHFUPucb1pSwRhO1GTNk7zE1kn936LaGZRkeTMCvYZ4G7a8HWDS6KHrWnoyAu7PHoQjUMKNruiE1bLBJ5XImddkaGwLwEsKn/BYpFl7Y9uU6jvQ2LmrZmOSR6GMNuTVQK65ClfJmRzWJiN9VWSV0grhLqiMojiYUr9OUH+h3ID47kG893AVtfXmn+l9ML85StAkMaZIynW7GmKtAMqgF7oRgcmvH4iCzCek6rw+HnKFb8U2szz/JXgPpeH3dHcFQqtCYyDMpCWIk91h9JKyDOq66SDDHaIOhjDprK7LpjOsZNfCtI3f9MBvU6UlDoudvZ84vyiyVS3GTDC9vbZlFEUx0hG8hodyxSlnf/ysf41qmPtA7zF9HCTrh4GvMyeXXaLjo55RIJ9jtgZbEiJPMDJ/4PYJVPaP5wVJB/4+uYsNNzaf9Joq2YRqRYjJ4F72HBxAGz4jcEmT9Pru+ULiQ8ow2bObGbfYW+mbe5ROz41lzMWYiVIPIWFmw4F0WqlBGWi7NOYpcrL6+5W1NPcKvPwGLvLCFm4Gbv2LLTyzca4d0YRhJMz3asWvto6fRYjxgR74P7DkuATd/Hwgw0xuewy0oYL6Tnq3O4dMHi8sQKh8vooVWE+YshQkMcEcYfFIBfyFKGWyAgoocXSVIkCEcYWFWhl+ycecADuVBpsGjD8FisnlvMsTXmO3iZ9RdM3nHAmNNfcC2e46uhEkWMHsWgP8HhDegij7OBP3FnH2bcJcO6K2cAnzSevz6R1WY4QecQGK46XWRlCSzL+pa5wSem50Ve76uAFOQ3FCUyWth/00qSzmlgjZBrrRnb+hi3B6Gi6ssBvqS0K6ZCuwm6i+vkUldX31MwFZHYwE+omRHi59JpsXgcF9JTJF4d4qtzwliYZUp4t9VuTLtpKKl5jbS9SmEjE65Ga7hYSzAsuXHlIbFCdRULw2nMjssvuC1DcVZZeXtcwa1FEj4jd7hQAAAIMHXgQRwg6JAAGWBpLEAQDR8t4fscRn+wIAAAAABFla')).decode())
The flags used in JScrewIt make the program support all node versions.
== Julia ==
Using multiple dispatch to implement several versions for user convenience.
# Deadfish implementation in Julia
# Run fully compliant version (infinite input/output loop):
# deadfish() or deadfish(0)
# Run version that exits when entering 'h':
# deadfish(1)
# Run version that simulates manual input and
# appropriate output, given the input string as a whole:
# deadfish("input string")
function deadfish()
#= Run fully compliant version of deadfish if
 no parameters are given =#
 deadfish(0)
end
function deadfish(compliance::Int)
 x=0
 while true
 print(">> ")
 input=readline(STDIN)[1]
 # Make sure x is not greater then 256 ;)
 x == 256 ? x=0 : nothing
 x == -1 ? x=0 : nothing
 input == 'i' ? x=x+1 :
 input == 'd' ? x=x-1 :
 input == 'o' ? println(x) :
 input == 's' ? x=x^2 :
 input == 'h' && compliance ==1 ? break : println()
 end
end
function deadfish(code::AbstractString)
 x=0
 for i = 1:length(code)
 input=code[i]
 println(">> $input")
 # Make sure x is not greater then 256 ;)
 x == 256 ? x=0 : nothing
 x == -1 ? x=0 : nothing
 input == 'i' ? x=x+1 :
 input == 'd' ? x=x-1 :
 input == 'o' ? println(x) :
 input == 's' ? x=x^2 : println()
 end
end
Example output of test strings for "true" deadfish overflow detection:
julia> include("deadfish.jl")
deadfish (generic function with 3 methods)
julia> deadfish("iissso")
>> i
>> i
>> s
>> s
>> s
>> o
0
julia> deadfish("iissiso")
>> i
>> i
>> s
>> s
>> i
>> s
>> o
289
== K ==
{1">>";0{x*2=-1 256?x:y@x}/("xkcdiso"!7#(1+;{x*x};{-1@$x;x};-1+))@0:0;.z.s`}`
== Keg ==
 0{'::"ÿ1+=$0<+['_0"] \>\>\
 ,,,,?:o=[':."]:i=['1+"]:d=['1-"]:s=[':*"
== Kipple ==
(i>r)
(r
 r-105 r>c 0>y c? (c y? 0>c?) (y a+1 1>f y?)
 r-100 r>c 0>y c? (c y? 0>c?) (y a-1 1>f y?)
 r-111 r>c 0>y c? (c y? 0>c?) (y a+0 a>@ (@>p) (p>q) 10>q y?)
 r-115 r>c 0>y c? (c y? 0>c?) (y a+0 a>m+0 m>n 0>s (m-1 n+0 s+n m?) s>a 0>s? y?)
 r>t
 
 a+0 a>b 0>y b+1 b? (b y? 0>b?) (y 0>a y?)
 a+0 a>b 0>y b-256 b? (b y? 0>b?) (y 0>a y?)
)
(q>o)
== Kitanai ==
* Compact version :
$0[0]#$1[input">> "]?(add(eq($0@)256)
(eq($0@)-1))([0])?(eq($1@)"i")($0[add@1])?
(eq($1@)"d")($0[sub@1])?(eq($1@)"o")
(print($0@))?(eq($1@)"s")($0[mul@@])&1
* "Clean" version :
$"accumulator"[0]
#
 $"userInput"[input">> "]
 ?(eq ($"accumulator" @) 256)
 ($"accumulator"[0])
 ?(eq ($"accumulator" @) -1)
 ($"accumulator"[0])
 ?(eq ($"userInput" @) "i")
 ($"accumulator"[add @ 1])
 ?(eq ($"userInput" @) "d")
 ($"accumulator"[sub @ 1])
 ?(eq ($"userInput" @) "o")
 (print($"accumulator" @))
 ?(eq ($"userInput" @) "s")
 ($"accumulator"[mul @ @])
&1
== Kotlin ==
fun main(args : Array<String>) {
 var isSquared : Boolean = false
 var input : String?
 var a : Int = 0
 while (true){
 print(">> ")
 input = readLine()
 when(input){
 "i" -> {if (a == 256 && !isSquared) a = 0; a++}
 "d" -> {if (a < 0 && !isSquared) a = 0; a--}
 "o" -> println(a)
 "s" -> {isSquared = (a >= 256); a *= a}
 else -> println()
 }
 }
}
== LOLCODE ==
#!/usr/bin/env lci
BTW, This is a Deadfish interpreter in LOLCODE.
HAI 1.3
HOW IZ I reading YR op
 GIMMEH op, FOUND YR op
IF U SAY SO
I HAS A x ITZ 0
IM IN YR reader...
 I IZ reading YR op MKAY TIL BOTH SAEM op AN ""
 op, WTF?
 OMG "i", x R SUM OF x AN 1, GTFO
 OMG "d", x R DIFF OF x AN 1, GTFO
 OMG "s", x R PRODUKT OF x AN x, GTFO
 OMG "o", VISIBLE x
 OIC
 EITHER OF BOTH SAEM x AN -1 AN BOTH SAEM x AN 256, O RLY?
 YA RLY, x R 0
 OIC
IM OUTTA YR reader
KTHXBYE
== Lua ==
#!/usr/bin/env lua
local acc = 0
io.write(">> ")
while true do
	local c = io.read(1)
	if not c then break end
	 if c == 'i' then acc = acc + 1
	elseif c == 'd' then acc = acc - 1
	elseif c == 's' then acc = acc*acc
	elseif c == 'o' then io.write(tostring(acc)) io.write('\n')
	elseif c == 'h' then break
	elseif c == 'r' then acc = 0
	elseif c == '\n' then io.write(">> ")
	else io.write('\n') end
	if acc == 256 or acc == -1 then acc = 0 end
end
Category:Implementations