nyuuzyou/wikis huggingface dataset:
Deadfish i

The Deadfish i language is an object-oriented version of Deadfish with a BF-like syntax, created by Abraham Karplus. A Deadfish i file (extension .dfi) is a sequence of object declarations. Note that this improved version does not restrict unsquared values to one byte.
== Naming ==
A lot of child languages take the name of their parent and add "++". However, the Deadfish family uses the "i" command to increment. Hence, "Deadfish i".
== Alphabet ==
The Deadfish i alphabet is much like the BF one, with a few differences:
* No , command: Deadfish i does not support input.
* The # character start a comment that goes to the end of the line.
* Unknown character are errors, not ignored.
== Object declaration ==
An object is declared with the syntax
 name<method
where name is a positive integer or 0 and method is a sequence of Deadfish i commands.
== Commands ==
Command	Name 	Pseudocode
+ 	Increment 	self.val += 1
- 	Decrement 	self.val -= 1
> 	Square 	self.val **= 2
[x 	Call (static) 	x.method()
] 	Call (dynamic)	self.val.method()
. 	Output 	print(self.val)
=== Calling ===
A static call [ is followed by a positive integer.
The method of the object with that number is called.
A dynamic call is a plain ]. It calls the method of the object n, where n is the value of the object using the dynamic call command. The value must be positive.
== Beginning ==
The program is begun by an implicit call to 
 0.method()
== Examples ==
Prints "1":
 0<+.
Infinite loop (requires two objects since 0 cannot be re-called):
 0<[1
 1<+.[1
== External resources ==
* Perl and Röda implementations based on one interpretation of language semantics. They can evaluate the example programs. I (implementor of the interpreters) have listed some thoughts about the semantics on the Goldfish page.
Category:Languages
Category:Joke languages
Category:Object-oriented paradigm
Category:2011
Category:Unusable for programming
Category:Output only
Category:Implemented
Deadfish with gotos and input

made by Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff (talk) 01:46, 3 September 2024 (UTC)
 . jumps to instruction accumulator
 , input
 h halt
 c output char
goto 0 if at 256
==Programs==
===Truth-machine===
 ,iiiis. soh ddddddddddddddddddddddddoiiiiiiiiiiiiiiiiiiiiiiii.
===Hello, World!===
iiisdsiiiiiiiiciiiiiiiiiiiiiiiiiiiiiiiiiiiiiciiiiiiicciiicdddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddcddddddddddddcdddddddddddddddddddddsddcddddddddciiicddddddcddddddddc
==Interpreter==
Written in Python.
def dwgai(program):
 accumulator = 0
 i = 0
 while i < len(program):
 if program[i] == "i":
 accumulator += 1
 elif program[i] == "d":
 accumulator -= 1
 elif program[i] == "s":
 accumulator *= accumulator
 elif program[i] == "o":
 print(accumulator)
 elif program[i] == ".":
 i = accumulator
 elif program[i] == ",":
 accumulator = int(input("Enter a non-negative integer: "))
 if accumulator < 0:
 accumulator = 0
 elif program[i] == "h":
 return
 elif program[i] == "c":
 print(end=chr(accumulator))
 if accumulator == -1 or accumulator == 256:
 accumulator = 0
 i += 1
 if i == 256 and i < len(program):
 i = 0
Shorter Version:
def dwgai(p):
 a,i=0,0
 while 1:
 if p[i]=="i":a+=1
 if p[i]=="d":a-=1
 if p[i]=="s":a*=a
 if p[i]=="o":print(a)
 if p[i]==".":i=a
 if p[i]==",":a=int(input())
 if (p[i]=="h")|(i>len(p)-2):return
 if p[i]=="c":print(end=chr(a))
 if a in [-1,256]:a=0
 i+=1
 if i==256:i=0
==See also==
* Deadfish
* Alivehyperfish
Category:Languages Category:2024 Category:Implemented Category:Unusable for programming Category:Deadfish derivatives
Deadfish~

Deadfish~ is a super-set of the Deadfish programming language made by Jonathan Todd Skinner aka User:Jonskinner in June of 2007. Deadfish~ adds fixed loops, ASCII output, and a few more features to the Deadfish programming language. There are no plans to implement any sort of input feature, though functional or object oriented Deadfish would be quite funny. So, you know, Deadfish~ is pronounced as Deadfish Tilde.
Unlike its predecessor, there is no set standard for interpreters or compilers, so developers have more freedom when implementing. Like its predecessor, the accumulator ranges from 0 to 255 unless it is squared!
== Instructions ==
i 	Increments the accumulator
d 	Decrements the accumulator
s 	Squares the accumulator
o 	Outputs the accumulator
c 	Outputs the accumulator as a character
{}	Instructions inside the curly braces are repeated 10 times
()	If accumulator is 0, then skip the statement inside
h 	Halt
w 	Output Hello, world!
== Implementation ==
A Python implementation of Deadfish~ is available on GitHub. A shorter Python implementation of Deadfish~ is also available on GitHub. Unlike the above implementation, this supports files that are >1000 bytes and does not exceed the maximum recursion limit.
There is an interpreter written in C-INTERCAL on the talk page.
== Sample Program ==
A hello world program.
 w
Print out the alphabet
 >>iisiiiis{ic}{ic}icicicicicic
 ABCDEFGHIJKLMNOPQRSTUVWXYZ
Let the world know what you think of Deadfish~
 >>iisiiiisiiiiiiiiciiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiciii{c}dddddddddcdddddddciiiiiiiiiicdddddddc
 Horrrrrrrrrrible
Compressed version:
 >>iisiiiisdd{i}cd{iiii}ciii{c}i{d}ciii{d}c{i}ciii{d}c
 Horrrrrrrrrrible
Output one million times
 >>iisiiiisi
 AAAAAA...(999994 characters ommited)
Salary program (lost out on $8848)
 iisiic{{{{{i}}i}}}o
Category:Joke languages
Category:2007
Category:Output only
Category:Implemented
Category:Deadfish derivatives
Category:Total
Category: Languages
Deadfsh

Deadfsh is an esolang created by User:Unname4798. It is like Deadfish, but there is no increment command.
== Commands ==
 d - decrement
 s - square
 o - output
== Interpreter ==
 var input = "ddso";
 var number = 0;
 for (var i = 0; i < input.length; i++) {
 if (input[i] = "d") {
 number -= 1;
 }
 if (input[i] = "s") {
 number *= number;
 }
 if (input[i] = "o") {
 console.log(number);
 }
 }
== Examples ==
=== XKCD Random Number ===
 ddso
== Variants ==
=== PocketFsh ===
==== Instructions ====
There are two commands:
 0 - d - decrement
 1 - s - square
One byte is 8 commands.
==== Examples ====
===== XKCD Random Number =====
 [space]
==== P.S. ====
After the execution is done, it will output the accumulator.
Category:LanguagesCategory:Accumulator-basedCategory:Deadfish derivativesCategory:Total
Deadman

go to or back to Deadfish here
Deadman is created by User:Win7HE, that contains new stuff like ♣, ♠, •, and input, and is a joke language.
also it doesnt contain the accu<0 or accu>255 stuff 
== Commands ==
☺ is i,
☻ is d,
♥ is s,
♦ is o,
♣ multiplies by 2,
♠ changes the code pointer position to the accumulator,
• sets the accumulator to nothing,
◘ sets the accumulator to input (the accumulator can be text, and ♦ a.k.a. o can print text.),
○ sets the accumulator to the accumulator and the 5 characters in front of it and skips them
◙ checks if the accumulator is the first 3 characters, if its false it will skip 10 characters
== Example Programs ==
=== Cat ===
•◘♦
=== Hello world program ===
•○Hello○, wor○ld!..♦
This program is pretty similar to the Outinp hello world program... anyways
=== Truth Machine ===
•○123 i○s one◘♦◙123•☺♦☺☺☺☺☺☺☺☺☺☺☺☺☺☺☺☺☺☺♠•☺☻♦
=== XKCD random number ===
☺☺♥♦
== External Links ==
the official interpretrer
Category:Languages
Category:Finite state automata
Category:Joke languages
Category:2025
Category:Implemented
Category:Program forms
Category:Total
Category:Accumulator-based
Category:Deadfish derivatives
Deadshark

Deadshark (v1.1) is a language based on Deadfish, created by User:Win7HE.
== Why "deadshark"?==
The language is called Deadshark because it's better, and has bigger code.
== Commands ==
There are two accumulators, accumulator 1 and accumulator 2.
.
Command	Behavior
#i 	Increment accumulator 1 or accumulator 2 if its swapped. It will increment by #.
#d 	Decrement accumulator 1 or accumulator 2 if its swapped. It will decrement by #.
0s 	Squares accumulator 1
qo 	Print contents of accumulator 1.
wo 	it adds the ascii character (number from accumulator 1) to console line # (number from accumulator 2)
eo 	Creates a empty item for ascii character printing.
0/ 	Swaps accumulators for i and d (does not swap values)
There is no 0h .
== Implementations ==
=== Scratch ===
It's in the external links, press "See inside".
== Example Program ==
 0/1i0/eo9i0s9dwo8i5i5i5i5i5iwo
This prints "Hi" into item 1 using ASCII printing
== External Links ==
* Official Interpreter
* Official Deadfish To Deadshark Converter
Category:Languages
Category:2024
Category:Output only
Category:Implemented
Category:Deadfish derivatives
Deadsnail

Deadsnail is an esolang created by User:None1.
Its goal is to annoy its users.
==Introduction==
Deadsnail is the same as Deadfish with character output. However, before executing every command (characters that aren't i,d,s or o are NOP commands, so they are still commands), it waits for 500 years. After that, there is a 99.999999999999999999999999999999999999999999% probability that it crashes abnormally for each command.
==Example Programs==
===Hello World===
iiisdsiiiiiiiioiiiiiiiiiiiiiiiiiiiiiiiiiiiiioiiiiiiiooiiio
dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddoddddddddddddo
dddddddddddddddddddddsddoddddddddoiiioddddddoddddddddo
dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddo
You need to wait for 4118266800000 seconds (which is 130500 years or about 4.12 trillion seconds) before it terminates, and like other programs in this language, this program usually crashes abnormally.
Note:Line feeds aren't part of program
==Interpreters==
===Python===
from time import sleep
import sys
from random import uniform
c=sys.stdin.read()
x=0
for i in c:
 for i in range(157788):
 sleep(100000)
 if uniform(0,1)<0.99999999999999999999999999999999999999999999:
 raise Exception
 if i=='i':
 i+=1
 if i=='d':
 i-=1
 if i=='s':
 i*=i
 if i=='o':
 print(chr(i),end=)
 i%=256
Category:Total
Category:Languages
Category:Joke languages
Category:Implemented
Category:Unusable for programming
Category:Output only
Deadsocket

Deadsocket is a Deadfish derivative invented by . It can open sockets, but not using them.
==Commands==
 Commands in Deadsocket
Command	Operation
i 	increment the accumulator
d 	decrements the accumulator
s 	open a socket and discard it
o 	output the accumulator
==Examples==
======
 iiiio
===Open a socket===
 s
==Interpreter==
===Python===
import socket
c=input()
x=0
for i in c:
 if i=='i':
 x+=1
 if i=='d':
 x-=1
 if i=='s':
 socket.socket()
 if i=='o':
 print(x)
 x%=256
Category:Languages
Category:Joke languages
Category:Unusable for programming
Category:Output only
Category:Total
Category:Finite state automata
Category:2023
DeafPig

DeafPig is a member of the Pig series along with Pig, SickPig, DeadPig, and QuinePig.
As with the other Pig languages, the only command is PIG.
The difference being your Pig is deaf, so he ignores everything you write and doesn't output any file.
== Various Programs in DeafPig ==
=== Hello, World! ===
DeafPig has no input or output, so there is no Hello, World! program.
=== Cat program ===
DeafPig is deaf, and cannot hear your screams.
=== Quine ===
DeafPig ignores you, so the only valid quine is to not write one at all:
== The Pig Series ==
The Pig series is a series of programming languages that are all based on Pig.
The languages are Pig, SickPig, DeadPig, and QuinePig.
Another language based on Pig is ExtendedPig.
==Interpreter==
Written in Python 3. The program should be supplied as a command-line argument.
=== ; ===
 ;
=== Inputfish ===
 i
Category:Languages Category:Unusable for programming Category:Joke languages Category:No IO Category:Total Category:Joke languages Category:Implemented
Death

Death is my excuse to stop working on Two-instruction madness!. And what do you know? Its extremely hard. It attempts to be harder than Malbolge (or Malbolge unshackled) without employing tricks like encryption. So, here are the instructions:
* nop.
* . takes the current value that the data pointer is pointing to, takes the accumulator, compares them and if the value is larger apply this: *d=(*d+a)/d
If its lower, apply this: *d=(*d+d)
Else, terminate.
* , does the same as a, but instead of compare, its comparing the parity. Same will do this: d=floor(*d+(d^2)/2)
* ! a=(*d+d-a)/*(d+1)
* / jumps back a+*d-d*2 instructions.
* ( outputs ceil(*d-d/a) as an ascii character.
* ) if there is a ( previously in the code, it will jump there and execute !!/.,.,, but if there isn't, the program jumps 1+a-*d+d instructions forwards, but if there is a .,/ or ( there, then it will jump back a+1 instructions.
And the number of every instruction has to be at most +-5 the average of all of the numbers of the instructions.
I think this is Turing complete, but it's hard to prove anything when a esolang is this strict.
Category:Languages Category:Output only
DeathScript

DeathScript is an esoteric programming language created by YourDeathIsComing. It operates on only 3 variables: A, B and C.
== Commands ==
Command 	Description
output [text] 	outputs text
outvar [var] 	outputs value of the variable
input [var] 	takes user input and saves it in the variable
random] 	sets the value of the variable
sub|mul|div|mod]	performs a math action on B and C and saves the result in A
switch [var] 	swaps the values of A and [var]
clear 	clears the screen
== Examples ==
===Hello, World!===
output Hello, World!
===Cat===
input A
outvar A
== Implementation ==
Implemention in Windows Batch.
@echo off
setlocal enabledelayedexpansion
for /F "eol=# tokens=1,2* delims= " %%a in (%1) do (
if %%a==output echo %%b %%c
if %%a==outvar (
if %%b==A echo !A!
if %%b==B echo !B!
if %%b==C echo !C!
)
if %%a==input (
if %%b==A set /p A=
if %%b==B set /p B=
if %%b==C set /p C=
)
if %%a==set (
if %%c==random (
if %%b==A set A=%random%
if %%b==B set B=%random%
if %%b==C set C=%random%
) else (
if %%b==A set A=%%c
if %%b==B set B=%%c
if %%b==C set C=%%c
)
)
if %%a==math (
if %%b==add set /a A=!B!+!C!
if %%b==sub set /a A=!B!-!C!
if %%b==mul set /a A=!B!*!C!
if %%b==div set /a A=!B!/!C!
if %%b==mod set /a A=!B! %% !C!
)
if %%a==switch (
if %%b==B (
set A_=!A!
set B_=!B!
set A=!B_!
set B=!A_!
)
if %%b==C (
set A_=!A!
set C_=!C!
set A=!C_!
set C=!A_!
)
)
if %%a==clear cls
)
set A=0
set B=0
set C=0
set A_=0
set B_=0
set C_=0
set skip=0
Category:Languages
Category:Implemented
Decision shrub

A decision shrub is a version of a decision tree where each node in the tree-graph must be able to link back to itself.
==Example of a decision shrub==
 A<--⸜
 / \ |
 / \ \
 ⸝-->B C \
 | / \ / \ \
 \ / | | \ /
 D E-->F--->G
Here, all nodes can link back to themselves (paths go down unless specified otherwise).
==See also==
* Decision tree
* 1͏͢ 
Category:Concepts
Decleq

Decleq (Decrement and jump if Less or Equal to zero) is an OISC by User:ChuckEsoteric08 inspired by P1eq.
==Command==
 a b c
Means: b=a-1 and jump to c if b is less or equal to zero.
==Memory-mapped I/O==
It is optional
 a -1 c
Outputs a
 -1 b c
Set b to user input.
==Examples==
===a=b=b-a with temporary address tmp<=0===
Written using SUBBIG Assembly:
 loop:b b NEXT
 a a :endloop
 tmp tmp :loop
 endloop:
==See Also==
* DJN OISC
* Subleq
Category:Languages Category:Turing complete Category:Turing tarpits Category:OISC Category:No IO Category:Unimplemented
Def run(t):

def run(t): is an esoteric subset of Python named by User: Jan jelo. In contrast to LambdaPython, there is no lambda or anything else here except def, return, function calling and name of function.
== Characters ==
There are only 9 characters in def run(t):
defrunt(): \n
This allows to define function,function call and return a value.
== Turing Completeness ==
In def run(t), the recursive depth limit has been removed, and it is possible to use it to encode untyped lambda calculus, so it ought to be Turing-complete. It is also possible to encode a Turing-complete basis from combinatory logic, like SKI:
 # K
 def f(t):
 def ff(tt): return t
 return ff
 # S
 def f(t):
 def ff(tt):
 def fff(ttt): return t(ttt)(tt(ttt))
 # I
 def f(t): return t
== Output ==
If the last line of program is a function call,assume that it is a church number and convert it into a integer to print.
== Example ==
Church numeral 
 def f(t):#this is zero
 def ff(tt):return tt
 return ff
 def ft(t):#this is succ
 def fft(tt):
 def ffft(ttt):return tt(t(tt)(ttt))
 return ffft
 return fft
 
fixed point combinator 
 def ftt(t):
 def fftt(tt):return ftt(t)(tt)
 return t(fftt)
 
Category: LanguagesCategory: Esoteric subsetCategory: 2024Category: Functional paradigmCategory: Output only
Define

Define is a subset of the C preprocessor invented by User:A with a small extension: the scans are infinite.
==Syntax==
* #define macro replacement
* ... and __VA_ARGS__ (These represent arguments for the macros)
* ## (connect two macros)
==Computational class==
The C preprocessor was not Turing-complete because of the limited scans applied. Define breaks this limit, thus making it Turing-complete. Link
Category:2019
Category:Esoteric subset
Category:Turing complete
Category:Turing tarpits
Category:Languages
Defined behavior

Defined behavior is the opposite of Undefined behavior (language), and it is also inspired by Undefined behavior (language). This esolang is invented by User:None1.
The behavior in this esolang is defined, but determined by the implementation, that means when you are making an implementation you can do anything you would like it to do, different implementations may cause completely different behvaior when executing the same program.
Literally, there is no specification
== Computational class ==
The computational class is also determined by the implementation, for example, if the implementation is a brainfuck interpreter, it will be Turing complete.
== Implementations ==
By definition, any program is a valid implementation of this language.
Category:Joke languages
Category:2023
Category:Unusable for programming
Category:Implemented
Definer

Definer is a programming language that is based on defining what things do. It is not complete yet. A program is split into three sections, the constants section, the definition section and the code section.
==Syntax==
The syntax looks like this:
 definer = constants definitions code
 constants = "constants:" constant*
 constant = <name> "=" valueOrParameter
 definitions = "definitions:" definition*
 definition = (<defname>? valueOrParameter?)* "=" (<name>? valueOrParameter?)*
 code = <<anything>>
 valueOrParameter = "0" | <name> "(" valueOrParamter ")" | <name>
 <name> = ("a" ~ "z" | "A" ~ "Z")*
 <defName> = ("a" ~ "z" | "A" ~ "Z" | "-" | "+" | "*" | "/" | "%" | "<" | ">" | "1" ~ "9" | "(" | ")" | "&" | "|" | ":" ... <<a lot more>>*
(subject to change)
==The way it works==
When the program is started, all constants in the code section are replaced by the values declared in the constants section. Then the rules of the definition section are constantly applied. When the rules don't change anything anymore, everything that can get changed back into one of the constants is changed back. Then the result is outputted to the screen.
==Examples==
Addition:
 constants:
 1 = s(0)
 2 = s(s(0))
 3 = s(s(s(0)))
 4 = s(s(s(s(0))))
 definitions:
 x + 0 = x
 x + s(y) = s(x + y)
 code:
 2 + 2
 output:
 4
Subtraction:
 constants:
 1 = (0)
 2 = ((0))
 3 = (((0)))
 4 = ((((0))))
 definitions:
 x - 0 = x
 (x) - (y) = x - y
 code:
 4 - 1
 output:
 3
Infinite loop:
 constants:
 definitions:
 z = z
 code:
 z
 output:
 z (loops forever)
Looping counter:
Somehow it will not print the process out. It will print an infinite number of asterisks.
 constants:
 definitions:
 * = **
 code:
 *
 output:
 ***************************...
Hello World:
 constants:
 definitions:
 code:
 Hello world
 output:
 Hello world
Truth-machine without input/output:
 constants:
 1 = 11
 definitions:
 code:
 Here is where your input goes...
 output:
 0 (when the code is not 1)
 111111111111111111111111111... (when the code is 1)
The language idea is currently under development. If you got any ideas, please add to the talk page.
Category:Self-modifying
Category:Output only
Category:String-rewriting paradigm
Category:2010
Category:Languages
Category:Declarative paradigm
Definitely unusable

Definitely unusable is a language that is supposed to be a derivative of Line Feed. Sadly, there is a bug in the implementation!PrySigneToFry maded Python implementation and it has no bug, even better than JS
==Syntax==
The only valid program is the single newline, which does nothing. Anything else will print out an error.
==Implementations==
Written in JavaScript:
function interpret(code) {
 if(code=='\n') {}
 else {
 console.log('Syntax Error:')
 // Uhhh...
 // How to print the contents of a variable?
 eval(code)
 // is that how you do it?
 }
}
===Another implementation in Python===
import sys
code = sys.stdin.read()
if code == "\n":
 pass
else:
 print(f"Syntax Error: {code}")
==See also==
* Line Feed
Category:Languages Category:Joke languages Category:Turing complete Category:Implemented Category:High-level
Definition

definition is a Python subset where you have to define a function to even run the program (variables, lists and dictionaries don't count, runing the first defined function is done automaticly)
==Syntax==
You have to define a function and put your code into that function:
 def main():
 x=0; print(x)
Variables can be outside functions. But that makes the variable global
To disable it from entering a function, you just do this:
 x=0
 def main():
 print(x)
 def main2():
 dont(x)
 print("x cannot enter this function")
 run(main,main2)
And if the program finds out you have a variable in a function that has this variable disabled:
 Line 6: Cannot use the disabled variable
And to make a local variable and add it to a function, do this:
 def main():
 x=0; print(x)
 def main2():
 do(x)
 print(f"{x=} value taken from the main function")
 run(main,main2)
 is self-explanatory. It just runs functions on a list.
The input command is invalid since you can make input using the run command and arguments
==Examples==
===Hello, world!===
 def m():print("Hello, world!")
===Truth-machine===
 def truth(x):
 if x==0 or x=="":print(0)
 else:one()
 def one():print(1);one()
 run(truth("input"))
replace the with your input
Category:Esoteric subsetCategory: LanguagesCategory:2024
Degration

Degration is a Brainfuck like language created by User:Bertrahm. However, the program is stored at the start of the tape and can be modified with the language's commands. 1/16 of all data on the tape is modified randomly every 8th instruction execution.
== Overview ==
Degration has a Tape, at the start of which the Program itself is stored and can be modified. The rest of the Tape starts of as empty. As mentioned before, every 8th instruction execution 1/16 of the data on the tape is degraded randomly,
this can also affect the Program.
Degration is Just in Time Compiled as the tape consists of bytes. Below is a Table of each command, its bytecode value and a brief description.
Command	Byte Code	Description
P+ 	$01 	Increments the Tape Pointer
P- 	$02 	Decrements the Tape Pointer
V+ 	$03 	Increments the Value of current Cell
V- 	$04 	Decrements the Value of current Cell
[ 	$05 	Opens a Loop
] 	$06 	Closes a Loop
* 	$07 	Outputs the value of the current Cell (ASCII)
? 	$08 	Gets user input (Saved starting at current Cell)
! 	$09 	Exits the Program
==== Looping ====
Loops are opened and closed using [ and ]. The closing bracket is prepended by a number from 0-255, when the closing bracket is reached, this number is compared with the number
in the current cell on the tape. If they match, the loop terminates. This form of looping greatly simplifies programming.
== Examples ==
The Program below demonstrates looping. It sets the starting cell to 9, the loop runs until it is decremented to 0.
 V+V+V+V+V+V+V+V+V+[V-0]!
This Program prints the Uppercase alphabet (atleast tries to)
 [V+65][*V+90]!
== External Links ==
* Source Code for Degration Interpreter written in Java
Category:Languages Category:Implemented Category:Brainfuck derivatives Category:Cell-based