nyuuzyou/wikis huggingface dataset:
Ecliptica

*Ecliptica is an esoteric programming language (esolang) created by Baldibacak (talk).
*Ecliptica uses signed 64 bit integer numbers for each memory cell.
*Ecliptica interpreter and ecliptica to c compiler source code can be found at https://github.com/serpentis64/Ecliptica 
== Commands ==
Command 	Description
+ 	Increases the value of the current memory cell by 1.
- 	Decreases the value of the current memory cell by 1.
? x () 	Checks if the value of the current memory cell equals to x; if true, executes the code inside `()`.
i 	Takes input from the user and saves it into a stack; whenever used, it pops from that stack into the current memory cell.
n 	Checks if the current cell is negative; if so, sets it to 0; if not, sets it to 1.
> 	Moves the pointer to the right.
< 	Moves the pointer to the left.
O 	Outputs the current memory cell as a character.
o 	Outputs the current memory cell as an integer.
[ 	Starts a loop (unconditional).
] 	returns to the loop.
x 	Terminates the program.
t 	Escapes from a loop.
l 	Stores the length of the input stack in the current memory cell.
p x 	sets cell x value same as current cell value
P x 	sets current cell value same as cell x
'x' 	sets current cell value to ascii value of x
r 	adds 1 or 0 randomly it doesnt actualy that much random
/comment/	comments are writen inside / / but they will effect speed of the program by a lot
"\n" 	NOP
== Example Programs ==
* Truth Machine
 - i?48(x)?49([1o])
 - The program begins by using `i` to get input from the user and save it into the current memory cell.
 - It then checks if the current memory cell is equal to 48 (the ASCII value for '0') using `?48`. If it is, the program executes `x`, terminating the program.
 - Next, it checks if the current memory cell is equal to 49 (the ASCII value for '1') with `?49`. If this condition is true,prints 1 in a loop.
* Cat
 - [iO]
 - The program starts with `i`, which gets input from the user.
 - It then outputs the input as a character using the uppercase `O`.
 - And then repeats the loop `[]` .
* hello world 
 - >++++++++[<+++++++++>-?0(t)]<O>++++[<+++++++>-?0(t)]<+O+++++++OO+++O>>++++++[<+++++++>-?0(t)]<++O------------O>++++++[<+++++++++>-?0(t)]<+O<O+++O------O--------O>>>++++[<++++++++>-?0(t)]<+O
 - hello world program translated from brainfuck to ecliptica only diffrence is loops
* Note: This language is highly case-sensitive and i input works same as brainfuck.
Category:Languages Category:2024 Category:Cell-based Category:Brainfuck derivatives Category:Implemented Category:Turing complete
Edition

The Edition language is invented by User:A.
Double speak example
I"$R.
C"F"0@i1@i
Explanation
I Take input
"$ Copy the input's length to clipboard
R. Read the current file's content into the buffer
C" Create a cursor clipboard chars below the current cursor
F" Repeat clipboard times
0@i Output the 0th cursor's content to the console and increment it
1@i Output the 1st cursor's content to the console and increment it
Brace is implicitly ended
Srcf0K1Pi
Explanation
There is implicit input if the I command is not used
S Save the input's length to the clipboard
r Append the file by its content
c Create a cursor clipboard chars below the current cursor
f Repeat clipboard times (with clipboard available)
0 Navigate to cursor 0
K Cut the current character to clipboard
1 Navigate to cursor 1
P Paste the clipboard
i Increment the cursor
Category:Languages Category:Unimplemented Category:2019
Ef

ef \ esoteric forth \ is an esoteric programming language designed by Total Vacuum in 2019.
 command ef FORTH
 ---------- ------------------- --------------------------
 comment \ \ ( ... )
 include % S" filename" INCLUDED
 number 0-9 0-9
 user a-z a-z
 define : ; : ... ;
 math + - * / < = > & | ^ + - * / < = > AND OR XOR
 stack # $ ? _ #UP $WAP ?ICK DR_P
 load/store @ ! , . @ ! C@ C!
 string " " S" string"
 char ' ' CHAR c
 asm ` ` CODE ... END-CODE
 if { ~ } IF ... ELSE ... THEN
 while ( ) IF BEGIN ... 0= UNTIL THEN
 loop [ ] DO ... -1 +LOOP
under construction ...
Egaharjb

Egaharjb is a very simple language I (Daniel Cristofani) designed accidentally. It consists only of regex substitutions with loops; it's meant for banging text files into a different shape, but is incidentally Turing-complete because Markov algorithms translate to it easily.
At the start of an egaharjb program, a file is read into egaharjb's buffer from standard input. The program manipulates the text in this buffer, and at the end the transformed text is sent to standard output.
An egaharjb program consists of statements, loops, and whitespace, A statement consists of a pattern string followed by a replacement string, both delimited by double quotes, and has the effect of replacing the first instance of the pattern in the buffer with the replacement. (Egaharjb transpiles to Perl and thus borrows Perl's regex syntax and its set of associated bells and whistles.) A loop, delimited by curly brackets, acts as a do-while (at least one pattern match was found during the last iteration); these are nestable. Statements and loops are otherwise performed sequentially.
Examples:
Compute bracket depth of brainfuck program (in unary):
 {"[^][]+" ""}
 {"]\[" ""}
 {"\[(I*)]" "I$1"}
 "(I*)" "$1\n"
Transpile egaharjb to Perl:
 "" "\#!/usr/local/bin/perl\n\$b=join(\"\",<STDIN>);\n\"a\"a\"a\""
 {
 "\"a\"a\"a\"[ \t\n]+" "\"a\"a\"a\""
 "\"a\"a\"a\"\{" "for(\$f[++\$l]=1;\$f[\$l];\$f[\$l-1]||=\$f[\$l])\{\n\$f[\$l]=0;\n\"a\"a\"a\""
 "\"a\"a\"a\"\}" "\}\n\$l--;\n\"a\"a\"a\""
 "\"a\"a\"a\"\"(([^\"\\]|\\.|\\\n)*)\"[ \t\n]*\"(([^\"\\]|\\.|\\\n)*)\"" "if(\$b=~s\"$1\"$3\")\{\$f[\$l]=1;\}\n\"a\"a\"a\""
 }
 "\"a\"a\"a\"(.+)" "ERROR: Unexpected input: $1\n\n"
 "\"a\"a\"a\"" "print \$b;\n"
History: I've occasionally found myself iterating regex find-and-replaces by hand. On 2020-04-14 I thought "this has to be a Linux utility", which may still be correct for all I know, but I didn't find it, so I made this. I didn't want to take a good name that someone else might want, so I used random.org's password generator tool and picked "eGAHArjB" from a list of five because it was pronounceable. This name should be treated as case-insensitive, and the file extension could be .egah I suppose.
Here's the Perl version of that transpiler:
 #!/usr/local/bin/perl
 $b=join("",<STDIN>);
 if($b=~s""\#!/usr/local/bin/perl\n\$b=join(\"\",<STDIN>);\n\"a\"a\"a\""){$f[$l]=1;}
 for($f[++$l]=1;$f[$l];$f[$l-1]||=$f[$l]){
 $f[$l]=0;
 if($b=~s"\"a\"a\"a\"[ \t\n]+"\"a\"a\"a\""){$f[$l]=1;}
 if($b=~s"\"a\"a\"a\"\{"for(\$f[++\$l]=1;\$f[\$l];\$f[\$l-1]||=\$f[\$l])\{\n\$f[\$l]=0;\n\"a\"a\"a\""){$f[$l]=1;}
 if($b=~s"\"a\"a\"a\"\}"\}\n\$l--;\n\"a\"a\"a\""){$f[$l]=1;}
 if($b=~s"\"a\"a\"a\"\"(([^\"\\]|\\.|\\\n)*)\"[ \t\n]*\"(([^\"\\]|\\.|\\\n)*)\""if(\$b=~s\"$1\"$3\")\{\$f[\$l]=1;\}\n\"a\"a\"a\""){$f[$l]=1;}
 }
 $l--;
 if($b=~s"\"a\"a\"a\"(.+)"ERROR: Unexpected input: $1\n\n"){$f[$l]=1;}
 if($b=~s"\"a\"a\"a\""print \$b;\n"){$f[$l]=1;}
 print $b;
Category: Turing complete
Category: Turing tarpits
Category: String-rewriting paradigm
Category: Low-level 
Category: Languages
Category: Implemented 
Category: 2020
Egel

Egel is an untyped functional programming language showcasing a novel graph rewriter piggybacking on C++ RAII. Its primary purpose is to allow for dynamic functional program exploration through relaxing many constraints typically found in mainstream functional languages.
Egel has variadic functions, constants that compose, supports any value to be thrown and caught (including closures), and support for concurrency.
== Example programs ==
=== Quine ===
say(List:foldr(+)""(List:map[K->List:nth K{"\\","\"",",","egelbot: say(List:foldr(+)","(List:map[K->List:nth K{","}] {3,1,1,4,1,0,0,1,2,1,0,1,1,2,1,2,1,2,1,3,1,2,1,4,1,2,1,5,1,5}))"}] {3,1,1,4,1,0,0,1,2,1,0,1,1,2,1,2,1,2,1,3,1,2,1,4,1,2,1,5,1,5}))
=== Other quine ===
[Q B L->say(L+Q+B+Q+Q+Q+B+B+Q+Q+L+Q)]"\"""\\""egelbot: [Q B L->say(L+Q+B+Q+Q+Q+B+B+Q+Q+L+Q)]"
=== List of primes ===
[F->F F tuple 2 111][F B L U->[true->F F([T->T T 2][T C->[_ true->B L|true _->B|_ _->T T(C+1)](0==L%C)(L<C*C)])(L+1)U|_->B](L<U)]
=== Mandelbrot fractal in ASCII-art form ===
[H->H -0.9;H -0.7;H -0.5;H -0.3;H -0.1;H 0.1;H 0.3;H 0.5;H 0.7;H 0.9][Y->[P->[H->H H""5][H B X->[true->H H(B+P X)(X- 1)|_->say B](-20<X)]][X->[P->[0 0->" "|0 1->"."|1 0->"'"|1 1->":"](P Y)(P(Y+ 0.1))]([P X Y->P P 0 X Y 0.0 0.0][P S X Y U V->[true->P P(S+1)X Y(X+U*U-V*V)(Y+2.0*U*V)|_->[true->1|_->0]((abs U)+(abs V)<2.0)](S<11)](0.1*tofloat X))]]
== External links ==
* Egel's website
* Interpreter source code
* Evaluator IRC bot source code
* Introduction to the language and interpreter
* Graph Rewriting with a Twist
Category:2015
Category:Functional paradigm
Category:Turing complete
Category:Implemented
Egnufeb

Egnufeb is a queue-based 2D esolang thought up by User:Emelang (emelchenko).
== Instructions ==
Arrows move the pointer around.
': Makes the pointer go into string mode where it puts whatever is in the quotes into the queue. If the pointer is already in string mode, it makes the pointer go out of string mode.
i: Takes in input from the user and puts into the variable v or whichever one its set to. BTW you need to put variables in curly brackets unless theyre in an f statement, we'll get to f later.
p: Prints the first value on the queue.
§: A Nop.
/: Jumps to the latest section sign (§) before it.
|: Discards a pointer, if there is only one pointer left then it will end the program.
f: An if instruction. Statements are put in round brackets and the code to execute if the statement is true are put in square brackets after the round brackets. If the statement is false, then it skips to the next instruction.
+, -, *, /, ^ and % are all pretty much self-explanatory.
@: Clones the pointer in all 4 directions.
?: Skips the next command if the queue is empty.
d: Declare a variable. The variable's name is in round brackets and the variable's value follows in square brackets.
== Examples ==
===Hello, World!===
>'Hello, World!'§p?/|
=== Cat Program ===
Regular Cat Program
>i{v}§p?/|
Looping Cat Program
>i{v}§p?/v
^/?p§{v}i<
Looping Cat Program w/o reversion
>i{v}§p?/v>i{v}§p?/v
 >^
^ <
=== truth-machine ===
>if(v=0)['0'p|]f(v=1)[§'1'p/]
=== Calculator ===
v <
>if(v=s)[|]v
v <
>i{a}i{b}iv
v <
>f(v=+)[a+b]f(v=-)[a-b]f(v=*)[a*b]f(v=/)[a/b]f(v=^)[a^b]f(v=%)[a%b]p^
=== A+B Problem ===
>i{a}i{b}+p
Category:Unimplemented
Category:2024
Category:Languages
Category:Two-dimensional languages
Category:Queue-based
EgoBot

EgoBot is an IRC bot for running esoteric programming languages, created by Gregor Richards. It may frequently be seen and experimented with in the #esoteric IRC channel, and its source is available at http://codu.org/projects/egobot/ . It also runs hills for the competitive programming languages FukYorBrane and BF Joust.
Currently it supports the following languages:
1L, 
2L, 
:///,
ADJUST, 
assembler,
axo, 
Befunge, 
BitChanger, 
Bitwise Cyclic Tag,
Boolfuck,
Brainfuck, 
C,
CHIQRSX9+,
C-INTERCAL,
CLC-INTERCAL,
C++,
Dimensifuck,
Forth,
Glass, 
Glypho, 
Kipple, 
Lambda, 
Lazy K, 
Linguine, 
Malbolge, 
Ook!,
pbrain, 
Perl,
Quantum brainfuck, 
Rail, 
Rhotor, 
SADOL, 
Sceql, 
sh,
Trigger, 
Udage, 
Underload,
Unlambda, and 
Whirl
(This list is not maintained, and is almost certainly incomplete. You can see the basic languages by typing "!help languages" or looking here , and recursively defined interpreters with "!userinterps".)
EgoBot is no longer active, but its successor HackEgo has inherited most of its interpreters, and makes them available using the ! HackEso command.
Category:Implementations Category:People
Eigenratio

The eigenratio of a self-interpreter (i.e. an interpreter written in the same language that it interprets) is a measure in the limit of the slowdown when several copies (a stack) of it are chained, each interpreting the next and the last one interpreting some arbitrary "outermost" program. The concept was named and investigated by Clive Gifford.
The name is based on "eigenvalue", as at least in simple cases it can be calculated as the largest eigenvalue of an explicitly constructed matrix with entries that are the number of each type of instruction needed to be run by an "inner" interpreter to simulate a given type of instruction in an "outer" one.
==Definition==
Given a self-interpreter I and an outermost terminating program P, let f(n,I,P) be the number of instructions run by the innermost interpreter in a stack of n of them where the outermost is interpreting P.
If the limit
\lim_{n\rightarrow\infty}\frac{f(n+1,I,P)}{f(n,I,P)}.
exists for all terminating P and is independent of P, then we call it the eigenratio of I.
More generally, the limit may not always exist, and may not always be independent of P. One case where the eigenratio does exist is if the self-interpreter is described by a primitive matrix.
==External resources==
*Eigenratios of Self Interpreters
Category:Concepts
Eitherf*ck

Eitherf*ck is a Brainfuck variant in which code is executed in both directions, starting at the center of the code.
The idea for the language was posted by User:80.213.159.15 who didn’t leave any identification.
 Commands:
 0	Center of code (only to clarify)	
 #	Does nothing(used only to make sure that the number of commands is an odd number)	
 > 	Move the pointer to the right
 < 	Move the pointer to the left
 + 	Increment the memory cell under the pointer
 - 	Decrement the memory cell under the pointer
 . 	Output the character signified by the cell at the pointer
 , 	Input a character and store it in the cell at the pointer
However, these commands are reversed when they're on the left side of the code.
This means that > will move the pointer to the left instead of to the right; that is, if it's on the left side. Same goes for the other commands; "+" becomes "-", "," becomes "." etc. when they're placed on the left side of the "0" sign.
The code is executed one by one character, in both directions; however, the right side always starts.
 Brainfuck example:
 1 2 3 4 5 6 7 8
 + + + + + > > +
 Eitherf*ck example:
 8 6 4 2 0 1 3 5 7
 - < - - 0 + + + >
An implementation of an Eitherf*ck interpreter written in Python can be found in this Github repo.
Category:Brainfuck derivatives
Category:Languages
Category:Implemented
Category:2018
Category:Cell-based
Category:Low-level
Ekativ

Ekativ is an esolang created by User:She.the.people, the name comes from a misspelling of Executive, I don't know why I just thought that sounded cool.
Anyways, this esolang uses a format similar to by+ and each character is called a "command", it also uses an 8 bit array of 16 cells.
 Ekativ Commands
Command	What it does
> 	Shift right in the cell array
< 	Shift left in the cell array
+ 	Increments the current cell selected, if a number (single digit integer or binary) is specified, add by that amount
- 	Decrements the current cell selected, if a number (single digit integer or binary) is specified, subtract by that amount
L 	Shift the number in the current cell left 1 bit, this also converts to binary
R 	Shift the number in the current cell right 1 bit, this also converts to binary
(...) 	Repeat everything in the parenthesis until the current cell is the number after the brackets, add a ? before it to break the loop immediately after the condition is met
! 	Output the current cell as a character
There are some errors that Ekativ can output as well.
 Errors
Symbol	Explanation 	Severity
% 	Divide by 0 	Warning
? 	inf or NaN was used 	Error
O 	Infinite loop (repetition for too long)	Warning
! 	Outputted invisible character 	Warning
For example,
++++++++>++++++(<++++++>-)<.
results in
0
== Programs Made ==
No programs have been made with this esolang yet
== Interpreters ==
No interpreters have been made for this esolang yet
== Note ==
This esolang is a WIP and could be changed at any time
Category:Languages Category:2024 Category:Brainfuck derivatives Category:Cell-based Category:Unimplemented Category:Output only Category:Finite state automata
Electric BitFunk

Electric BitFunk is a two-dimensional esoteric programming language created by User:Koen on 2012, september 9. It was inspired mainly by Electric Go, an "esoteric" variant of the game of go (see External resources below).
Electric BitFunk operates on a tape of bits, using instructions borrowed from BitChanger. However, those instructions affect the playfield as well, making programming in Electric BitFunk a challenge somewhat similar to Half-Broken Car in Heavy Traffic.
==Language overview==
A program in Electric BitFunk consists of a two-dimensional grid, each cell in the grid being initially Blank, Positive, or Negative. In addition, one cell is the 'start' cell. The start cell cannot be Blank.
There is an instruction pointer, initially pointing to the start cell. The instruction pointer never points to Blank cells.
The execution of an Electric BitFunk program consists in a loop:
:Execute the current cell as a BitChanger instruction
::If the current cell is Negative, move the bit pointer one space to the right, then flip the pointed bit
::If the current cell is Positive, move the bit pointer one space to the left
:Apply the current cell's electric field to neighbouring cells
::In every cardinal direction, move the nearest non-Blank cell one space nearer if its polarity is opposite to that of the current cell, one space away otherwise
:::When moving a cell:
::::If the target cell is Blank, switch the two cells (that is, the target cell becomes either Positive or Negative, and the moved cell becomes Blank
::::If the target cell is non-Blank, the "move" operation is a no-op; however the "moved" cell is considered as having been moved nonetheless
:Move the instruction pointer to a new cell
::Up to four cells have been moved when applying the current cell's electric field
::Select the nearest of those 0-to-4 cells
:::In case of a tie, ignore the tying cells for the purpose of computing the nearest cell
::Move the instruction pointer to the selected cell, then continue to the next iteration of the loop
:::If no cell has been selected, either because no cell was moved or because of ties between the moved cell, execution halts.
==External resources==
A brief description of Electric Go, the game which inspired Electric BitFunk
Category:Languages
Category:Two-dimensional languages
Category:Self-modifying
Category:Cell-based
Category:No IO
Category:Brainfuck derivatives
Category:Low-level
Category:Unknown computational class
Category:Low-level
Category:Unimplemented
Category:2012
ElemScript

Elemscript is an esoteric programming language made by User:Areallycoolusername. All commands are carried out using the atom formulas for different elements (from the periodic table). It's stack based.
== Specifics ==
For example, a water molecule's formula is H2O. So, you would put H-O-H as valid command in the language. The formula for hydrogen peroxide is H2O2, so the formula as a command is H-O-O-H. The first element in the periodic table is hydrogen, so all code must start with H. The last element in the periodic table is oganesson. However, since it has no known compounds, you just use Og for a command. All code must end with Og. Here is a chart with the commands so far.
== Commands ==
Formula command 	Operation
H-O-O-H (Hydrogen) 	Starts code.
C-C-C-C-C-C-H-O-O-H-H-O-O-H-H-O-O-H-H-O-O-H-H-O-O-H-H-O-O-H-H-O-O-H-H-O-O-H-H-O-O-H-H-O-O-H-H-O-O-H-H-O-O-H-O-O-O-O-O (Since paper has cellulose in it)	Prints anything after the command.
Al-Al-Si-Si-O-O-O-O-O-OH-OH-OH-OH (Clay, since clay can be made into anything.) 	Declares variable. Syntax: Command,var name,var value
Og 	Ends code.
== Implementations ==
This language is suppose to be HUGE. Therefore, the interpreter for this language will change for every five new elements added, until the entire periodic table is covered. Only printing is implemented for now. Here's the code. 
#include <iostream>
using namespace std;
int main(){
	string frst;
	getline(cin,frst);
	if(frst!="H-O-O-H"){
		cout<<"No opening command.";
		return 69;
	}
	string snd;
	getline (cin,snd);
	if(snd!="C-C-C-C-C-C-H-O-O-H-H-O-O-H-H-O-O-H-H-O-O-H-H-O-O-H-H-O-O-H-H-O-O-H-H-O-O-H-H-O-O-H-H-O-O-H-H-O-O-H-H-O-O-H-O-O-O-O-O"){ 
	cout << "No commands.";
	return 69;
	}
	string yeet;
	getline(cin,yeet);
	cout << yeet;
	string end;
	getline(cin,end);
	if(end!="Og") {
		cout << "No end command";
	return 69; } else {
		return 69;
	}
}
== Hello World Program ==
H-O-O-H
C-C-C-C-C-C-H-O-O-H-H-O-O-H-H-O-O-H-H-O-O-H-H-O-O-H-H-O-O-H-H-O-O-H-H-O-O-H-H-O-O-H-H-O-O-H-H-O-O-H-H-O-O-H-O-O-O-O-O
Hello, world!
Og
Category:Thematic
Category:Stack-based
Category:2019
Category:Languages
Elfroh

elfroh is an esoteric programming language created by user Larryrl, in 2022, whose name is an acronym for Esoteric language From Hell.
==Transpiler==
The transpiler, which is coded using Qb64, takes elfroh source files as input and produces qb64 code for output
which can be compiled on windows using QB64 Phoenix edition.
==Syntax==
The syntax of the language is a bit tricky as every character in the source code must be a symbol and it takes 2 symbols to make a letter or number.
The External link below is to the source code written in QB64 which at the end of it shows which symbol pairs make up which letters, numbers and
even other symbols.
* data is translated from symbols to letters and numbers
* Jumping from place to place within a source code is supported
* limnited math functions
* a very limited subset of basic
==Instructions==
Viewing the source code, and reviewing the case statements in it, you can easily view the translate subroutine and figure out the keywords for the language.
==Example==
This example will print the classic "Hello World" greeting:
 Hello World #1 In elfroh
(])[!? )(!)][][]! ?)]!)[][!(^^
The QB64 output is 
print hello world!
 
This example creates an endless loop but also prints hello world!.
][(]
(])[!? )(!)][][]! ?)]!)[][!(^^
!(]!
==External Link==
https://www.dropbox.com/s/gzz5cofvqlro6s8/elfroh.bas?dl=0
Category:Languages
Category:2022
Category:Implemented
Eliminate

Eliminate is an esolang created by User:None1, it is a derivative of Basilisk.
==Commmands==
This esolang has commands the same as Basilisk.
==Execution==
Instead of summoning a snake, this esolang eliminates the current user before executing the program.
==Computational Class==
This esolang is certainly uncomputable, because a computer can't eliminate anything!
Category:Languages
Category:Joke languages
Category:Unusable for programming
Category:Uncomputable
Category:2023
Ellipsis

Ellipsis is an Esoteric programming language created by Bradley Grzesiak in 2012. It has two modes, each of which use only one character. In the first mode, the character is the Unicode ellipsis ('…', U+2026). In compatibility mode, the character is the period
Ellipsis compiles into Brainfuck. To write an Ellipsis program, enter N ellipses (or sets of 3 periods) into your UTF-8 encoded source file. Then, convert N into its big-endian octal representation… call this OCT. Convert each digit of OCT into new characters based on the conversion table to produce a Brainfuck program. Because the UTF-8 encoding for ellipsis is 3 bytes, a simple (unsafe) compiler for either mode can simply take the source file's size and divide by 3 to obtain N.
A sample program (standard file extension is "..") that beeps is simply 4,793,492 ellipsis characters.
octal digit	output
0 	>
1 	<
2 	+
3 	-
4 	.
5 	,
6 	[
7 	]
A reference implementation in ruby is as follows:
 (File.size(ARGV[0])/3).to_s(8).chars.map{|x| print %w(> < + - . , [ ])[x.to_i]}
==See also==
* A
* MGIFOS
* Unary
* Lenguage
* Dotfuck
Category:Languages
Category:Brainfuck equivalents
Category:2012
Category:Implemented
Category:Cell-based
Category:Turing complete
Category:Low-level