nyuuzyou/wikis huggingface dataset:
255

255 is an esoteric programming language developed by User:AceKiron where operations are represented by a single byte. Currently available operators are:
 Label
 Hex
 Description
 Following parameters
 
 PUSH_N
 0x00
 Pushes the following N values onto the stack.
 How many values to push onto the stack, after that follow the values.
 
 
 REVERSE_STACK
 0x01
 Reverses the stack.
 
 
 
 PRINT_N
 0x02
 Pops N values from the stack and prints them as characters.
 How many characters to print.
 
 
 SET_MARK
 0x03
 Sets a mark that you can later go back to.
 What number should be assigned to the mark.
 
 
 GOTO_MARK
 0x04
 Goes back to a previously set mark.
 What number should be assigned to the mark.
 
 
 IF_N
 0x05
 Pops 1 value from the stack, if it's 0 it skips N amount of bytes.
 How many bytes should be skipped if the statement is 0, after that follow the bytes for when it's anything else.
 
 
 DUPLICATE
 0x06
 Duplicates the top value on the stack.
 
 
 
 MATHS
 0x07
 Pops the top 2 values on the stack and pushes the output of a math operation with those 2 values onto the stack.
 
 
 Label
 Hex
 
 ADD
 0x00
 
 
 SUBTRACT
 0x01
 
 
 MULTIPLY
 0x02
 
 
 DIVIDE
 0x03
 
 
 POWER
 0x04
 
 
 MOD
 0x05
 
 
 
 
 
 PRINT_N_RAW
 0x08
 Pops N values from the stack and prints them raw (no converting to characters).
 How many values to print.
 
 
 SWITCH_TOP
 0x09
 Switches the top value on the stack and the one below it from positions on the stack.
 
 
== Popular problems ==
=== Hello, world! ===
 [0x00, 13, 'H', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd', '!', '\n', 0x01, 0x02, 13]
=== Truth-machine ===
The 3rd value here represents the input given to the truth machine.
 [0x00, 1, 1, 0x05, 9, 0x03, 0, 0x00, 1, '1', 0x02, 1, 0x04, 0, 0x00, 1, '0', 0x02, 1, 0x08, ]
=== 99 bottles of beer ===
 [0x00, 1, 99, 0x03, 0, 0x06, 0x05, 139, 0x06, 0x08, 1, 0x00, 30,
 '\n', ',', 'l', 'l', 'a', 'w', ' ', 'e', 'h', 't', ' ', 'n', 'o', ' ',
 'r', 'e', 'e', 'b', ' ', 'f', 'o', ' ', 's', 'e', 'l', 't', 't', 'o',
 'b', ' ',
 0x02, 30, 0x06, 0x08, 1, 0x00, 49,
 '\n', ',', 'd', 'n', 'u', 'o', 'r', 'a', ' ', 't', 'i', ' ', 's', 's',
 'a', 'p', ' ', ',', 'n', 'w', 'o', 'd', ' ', 'e', 'n', 'o', ' ', 'e',
 'k', 'a', 'T', '\n', '.', 'r', 'e', 'e', 'b', ' ', 'f', 'o', ' ', 's',
 'e', 'l', 't', 't', 'o', 'b', ' ',
 0x02, 49, 0x00, 1, 1, 0x01, 0x07, 0x01, 0x06, 0x08, 1, 0x00, 31,
 '\n', '\n', '.', 'l', 'l', 'a', 'w', ' ', 'e', 'h', 't', ' ', 'n', 'o',
 ' ', 'r', 'e', 'e', 'b', ' ', 'f', 'o', ' ', 's', 'e', 'l', 't', 't',
 'o', 'b', ' ',
 0x02, 31, 0x04, 0, 0x00, 31,
 '.', 'l', 'l', 'a', 'w', ' ', 'e', 'h', 't', ' ', 'n', 'o', ' ', 'r',
 'e', 'e', 'b', ' ', 'f', 'o', ' ', 's', 'e', 'l', 't', 't', 'o', 'b',
 ' ', 'o', 'N',
 0x02, 31]
=== Fibonacci sequence ===
 [0x00, 6, 0, 1, '\n', 1, '\n', 0, 0x08, 1, 0x02, 1, 0x08, 1, 0x02, 1, 0x03,
 0, 0x06, 0x01, 0x07, 0x00, 0x06, 0x08, 1, 0x00, 1, '\n', 0x02, 1, 0x04, 0]
Category:2022
Category:Stack-based
Category:Languages
25 bytes o:

25 bytes o: is an esoteric programming language designed to have the least functionality and smallest compiler. All 25 bytes o: programs are identical, being either the cat program (for one iteration), or are all quines, depending on if the prompt() takes user input or characters from the source code it is executing, respectively.
== Implementations ==
=== python intepreter ===
Here is an interpreter:
 xyz=input();
 print(xyz);
=== Python interpreter 2 ===
This is another interpreter by PrySigneTofry, with 25 bytes, and following PEP8.
 xyzt=input()
 print(xyzt)
Category:Languages
Category:Joke languages
Category:Implemented
Category:Total
Category:Unusable for programming
Category:Zero-dimensional
Category:Output only
2B

2B is an esoteric programming language created by user:David.werecat in which memory is stored in a tape where each cell is a separate tape of bytes.
== Instructions ==
During these examples, the character " represents any number from 0-9 and the character _ represents a string of any length. Whenever 0 is used, it is interpreted as 10.
Instruction	Description
0 	Zeros the current cell. This function also clears the overflow flag.
{ 	If the current cell is zero, jump to the matching }.
} 	Do nothing. A placeholder for the { instruction.
( 	Read a byte from input and place in the current cell.
) 	Write the current cell's value to the console.
x 	Stores the value of the current cell in a temporary register.
o 	Writes the value in the temporary register to the current cell.
! 	Performs a carry operation. If the last addition overflowed, then increment the current cell by one. If the last subtraction underflowed, the decrement the current cell by one.
? 	Performs a binary NOT on the current cell.
+" 	Adds an amount to the current cell.
-" 	Subtracts an amount from the current cell.
^" 	Moves the subtape up a number of times.
v" 	Moves the subtape down a number of times.
<" 	Moves the tape left a number of times.
>" 	Moves the tape right a number of times.
:_: 	Defines a label with name _.
*_* 	Jumps to a label of name _. If the label is not within the current function, then the behavior of the jump is undefined.
@_@ 	Calls a function of name _.
~_~ 	Defines a function of name _. The function is treated as a separate chunk of code, so functions can be defined anywhere.
% 	Ends a function definition.
#_# 	Is a comment.
Spaces are treated as NOPs. Any tabs or newlines are interpreted as whitespace and removed before interpreting. 
== External resources ==
* Visual Basic .NET interpreter and sample programs
Category:Languages
Category:2012
Category:Turing complete
Category:Low-level
Category:Implemented
Category:Cell-based
2D-BCT

==2D-BCT==
I want to design a language that includes all the purposes of an esolang.
==BCT==
A BCT program is any finite string of bits (commands), executed as follows:
Command	Execution
0 	Delete the leftmost data-bit.
1 	Goto the next command (say x). If the leftmost data-bit is 1, copy x to the right end of the data-string.
If the program-string or the data-string is initially empty, execution halts immediately; otherwise, starting at the leftmost program-bit and halting only when the data-string becomes empty, the commands are executed in cyclic sequence from left to right (the leftmost bit following next after the rightmost bit). 
The program pointer advances one bit after each command-execution, and also advances one bit when the goto in a 1-command is executed; consequently, a 1-command always pairs with the next command after it (say x), such that 1x is effectively a composite command whose execution is
 if the leftmost data-bit is 1:
 copy x to the right end of the data-string 
Four equivalent variations of BCT are obtained by exchanging the roles of symbols 0 and 1 as commands, and by varying the parity required in the condition for copying a bit to the end of the data-string. 
That makes it a Turing-Tarpit(Has minimalism), and obfuscated. 
==2D Commands==
Command	Execution
> 	Move the PC direction right.
< 	PC-Left.
^ 	PC-Up.
v 	PC-Down.
@ 	PC-End.
It follows the directions and puts them one-by-one in an array, excluting them as in BCT.
This makes it new-conceptual. It also becomes themed, to look like Befunge.
==Brevity and Joking==
2D-BCT also adds all of the one-byte commands in Losescript, making it win a lot of golf contests.
This makes it have brevity(This also includes the joking property of Losescript.).
==Weirdness==
This Esolang is also weird.
If you use any of the commands that is not mentioned, the program will enscript the code forever, making it next to impossible to use.
Category:Languages
Category:Turing complete
Category:Two-dimensional languages
Category:Unimplemented
2D-Reverse

2D-Reverse is a esoteric programming language invented by User:Zzo38. It is a reversible programming language. There are 2 memory-spaces, which are 2D infinite in all directions, and the value of each is 2 integers, a horizontal value and vertical value (it can be represented by a ordered pair or a complex number), all values are starting at zero. Each memory space has its own pointer. There is also 1 program pointer that can be in one space in the program, and a direction (N, S, E, W). It starts at the $ and going east. The program pointer will wrap around the program area.
==Commands==
* \ or / = Program pointer reflects off of the mirror.
* 1 = Move first memory pointer in same direction as program pointer is moving.
* 2 = Move second memory pointer in same direction as program pointer is moving.
* $ = Program starts here.
* @ = Program can end here.
* s = Swap values at first memory pointer and second memory pointer.
* X = Acts as / if value at first memory pointer (both horizontal and vertical) is zero, or \ if is non-zero.
* + = Value at first memory pointer is adjusted 1 space by direction of program pointer. (Ex: (0,0) W = (-1,0) and (6,7) N = (6,8))
* = = Horizontal value of value at first memory pointer is XORed by horizontal value of value at second memory pointer.
* x = Acts as \ if horizontal value at first memory pointer is zero, or / if is non-zero.
* C = If program pointer east, then value at first memory pointer is rotated clockwise (as a complex number: multiply by -i), if program pointer west, then value at first memory pointer is rotated counter-clockwise (as a complex number: multiply by +i), if north or south then it does nothing.
* . or space = Does nothing.
* ; = Program pointer jumps to next command past next ; in same direction as it is moving. If there isn't any, then it wraps around the program area to the next ; command.
==Examples==
If value at pointer is (1,0) or (0,0), it will switch the value:
 /+X+\
 $X \..@
 \.../
Move memory pointer right
 $1@
Move memory pointer left
 /.\
 $\1\@
 \./
Loop while not zero (put inside-loop code at * and extend the other lines with periods or spaces to match the length):
 /.2*.\
 = .
 $2s+s=X....x=2@
 \..../
I believe this makes it Turing-complete.
Category:Languages
Category:Reversible computing
Category:2006
Category:Two-dimensional languages
2DBFIPM

2DBFIPM (2-dimensional brainfuck! instruction pointer moves!) is an esolang created by User:Tommyaweosme
== Commands ==
 same as brainfuck
 # start instruction pointer movement
 v move instruction pointer down
 } move instruction pointer right
 ^ move instruction pointer up
 { move instruction pointer left
 yes, commands from brainfuck can be used in here, and the instruction pointer can go down into the movement pointer section
 
 instruction pointer starts at top right, and there is a second one running the pointer for instructions for the
 movement, and it constantly goes right and cannot be moved.
== Infinite loop ==
 #}{
== Cat (imperfect) ==
 +.
 #}[{,}]
== Truth machine ==
 .
 # ,>++++++[>++++++++<-]<,[}vv]>>}}
 [>>+<<-]>>}.{
== Portals variant (2DBIFPMNWP) ==
There is a portals variant called 2DBIFPMNWP (2-dimensional brainfuck! instruction pointer moves! now with portals!) where uppercase letters are "portals".
The only advantage that this has over the other version is that it takes less move commands to get certain places.
== Interpreters ==
None yet.
Category:2024Category:LanguagesCategory:Brainfuck derivativesCategory:Turing complete
2DChanger

2DChanger is BitChanger, except it is two-dimensional.
==Commands==
Command	Meaning
} 	flip bit and move bit pointer to the right
< 	move bit pointer to the left
+ 	if current bit is not zero, move instruction pointer (IP) clockwise, else counter-clockwise
==Examples==
===Hello, World!===
The following program replicates the bits corresponding to the ASCII codes contained in the text “Hello, World!” in the memory. Each character is represented by eight bits, from most significant to the least significant position. Please note that a single zero-bit is appended to the memory as a consequence of the necessity to move the cell pointer during the bit setting process. Each row of the program serves to encode one character from the message.
 }<}}}<}}<}}}<}}<}}<} }<+
 +}}<}}}<}}<}}}}<} <}+
 +}<}}}}<}}}}<}}<} }<+
 +}<}}<}}}}<}}}}<} <}+
 +}<}}}}<}}}}} }<+
 +}<}}<}}}}<}}}<}}<} <}+
 +}<}}<}}}<}}<}}<}}<}}<} }<+
 +}}}}<}}}<}}}<} <}+
 +}<}}}}<}}}}} }<+
 +}<}}}<}}<}}}}}<} <}+
 +}<}}}}<}}}}<}}<} }<+
 +}<}}<}}}<}}<}}}}<} <}+
 +}<}}<}}}<}}<}}<}}<}} 
==Interpreter==
* Common Lisp implementation of the 2DChanger programming language. The program also includes a text program generator which produces the 2DChanger source code capable of replicating a string's ASCII codes in the memory in binary form.
Category:Languages
Category:Cell-based
Category:Turing tarpits
Category:Brainfuck derivatives
Category:Low-level
Category:No IO
Category:Two-dimensional languages
Category:Implemented
Category:2022
2D BF

Our goal is, not to minimalize, but to make a fully functional 2D BF, and THEN minimalize it.
--Possible candidates so far--
* Enigma-2D
* Minimal-2D
* SNUSP
* Home Row
* Minifuck-2D
* Sansism
* Around and around, sleeping sound
* 2DFuck
* 2b 4 commands
Put your own suggestions for a 2D BF!
Category:2009
Category:Brainfuck
2D imensional

==Commands==
Cmd 	What it does
>^<v 	Moves right, up, left, down.
S 	Is the beginning location of the pointer. The pointer automatically starts moving right.
px 	Prints x. x can only be a number, a string, a variable, or a combination of the three. The pointer continues going right.
n
<nowiki>|</nowiki>-----<nowiki>|</nowiki>
- -
- -
<nowiki>|</nowiki>-----<nowiki>|</nowiki>	When the pointer encounters the box, the pointer goes into the box and does everything in the box until it reaches the outside of the box. Next, the pointer repeats the first step n-1 times. Then the pointer goes to the bottom right of the box and continues going right.
i 	Asks for input and stores it to x. The pointer continues going right.
s3+1tox	Stores 3+1 to x. The pointer continues going right.
def"function name"
<nowiki>|</nowiki>-----<nowiki>|</nowiki>
- -
<nowiki>|</nowiki>-----<nowiki>|</nowiki>	Defines a function with the name "function name". When the pointer reaches the box, it goes inside the box and does everything inside the box. The pointer goes to the bottom right of the box and continues going right.
nnnn
ifcondition( )
 ( )
 ( )
 uuuu	Does everything between the parentheses, "n"s, and "u"s if condition is true and the pointer is on the leftmost i. The pointer goes to the bottom right of the box and continues going right.
==Examples==
===Hello, world!===
Sp"Hello, world!"
===Truth machine===
 nnn
Sifcondition(p1<) nn 
 uuuifcondition(p0)
 uu
Category:2021
Category:Languages
2L Turing-completeness proof

It can be proven that 2L is Turing-complete by making a translation table from Brainfuck (a known Turing-complete language) to 2L. This document shows how to translate any Brainfuck program (minus input and output, which are not necessary for Turing-completeness) to 2L.
None of this is even vaguely optimal; there are infinitely better ways to do anything you could do by copying in these blocks. This page only serves to prove that 2L is Turing-complete.
Simply take the 2L blocks and stack them horizontally, starting with this block:
 _
 _
 _
 _
 +
Brainfuck command2L blockNote
+
 _ 
 _ 
 _ 
 * 
-
 __________ 
 __+__+____ 
 ___++___+_ 
 ______+___ 
 _+__*__+__ 
 _+___+____ 
 +________+ 
 __+____+__ 
 ________+_ 
>
 _______ 
 __+____ 
 _+___+_ 
 ___+___ 
 _+__+*_ 
 +_____+ 
 __+_+__ 
 _____+_ 
<
 _______ 
 __+____ 
 _+___+_ 
 ___+___ 
 _+*_+__ 
 +_____+ 
 __+_+__ 
 _____+_ 
[
 _____+___ 
 _+_______ 
 _+_____+_ 
 ______+__ 
 ____+____ 
 ___+____+ 
 _____++__ 
 ___+___+_ 
 _________ 
 _________ 
 __+_+____ 
 +________ 
 _______+_ 
 _+_______ 
For sub-loops, you will need to put the bottom block down farther:
__+_+____
+________
_______+_
_+_______
]
 ______ 
 _+____ 
 +___+_ 
 __+___ 
 ___+__ 
 ______ 
 ______ 
 ______ 
 ______ 
 _____+ 
 __++__ 
 ___++_ 
 _+____ 
For sub-loops, you will need to put the bottom block down farther:
_____+
__++__
___++_
_+____
Category:Proofs
2Swap

2Swap is an esolang by VilgotanL with only two instructions and two unbounded registers, it is based on a two-register Minsky machine.
== Instructions ==
* 	Swap the current register with the other register and increment the current one after the swap
-<n>	Decrement the current register unless it is already zero in which jump to the start of the line <n> with line numbers starting at one, <n> can be omitted but if the register happens to be zero when <n> is omitted, the behaviour is undefined.
Any other characters are ignored.
== Examples ==
=== Increment the second register indefinitely ===
**-
-1
== Computational class ==
2Swap is Turing-complete since a two register Minsky machine can quite easily be translated to 2Swap, Minsky machines with two or more registers have been shown to be Turing-complete.
For example, incrementing the first register: *-*, incrementing the second register: **-
== Implementations ==
Python implementation by the creator
Category:Languages
Category:Turing_complete
Category:Turing_tarpits
Category:No_IO
Category:2021
Category:Implemented
2 Bits, 256 Bytes

2 Bits, 256 Bytes is simply 2 Bits, 1 Byte by User:Gilbert189 but now, the 1 byte limit is now 256 bytes.
The only major difference is that the END instruction will only end the program if it is the end of the code.
This allows this:
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
Output:
mmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm
Category:Joke languages
Category:Low-level
Category:Unusable for programming
Category:Self-modifying
Category:Output only
Category:2022
Category:Languages
2 Bits and Bytes

2 Bits and Bytes (or 2 Bits, N Bytes) is the successor of 2 Bits, 1 Byte, an assembly language for a 2-bit CPU, made by User:Gilbert189. Unlike 2 Bits, 1 Byte, this language allows the memory size to be infinite by making all absolute operations relative.
It's still very useless though.
== Operations ==
The following are instructions of 2 Bits and Bytes:
Code	Name	Description
00 	DON 	DO Nothing.
01 	ACT 	
From	To 	
00 	11 	
01 	10 	
10 	00 	
11 	01 	
The instruction pointer can wrap around, thus allowing more "complicated" programs.
== Programs ==
Programs can be represented by a string of characters (like most languages here).
For example:
 Hi
becomes:
 01001000 01101001
which, when disassembled, becomes:
 ACT +00b
 JMP +00b
 ACT +10b
 JMP +01b
== Examples ==
=== Hello, world ===
This is found by computer search (since I don't feel like programming in this language).
 jgîlo, world
(This will not work correctly when encoded in UTF-8!)
== Interpreters ==
* Python interpreter by User:Gilbert189 
Category:Joke languages
Category:Low-level
Category:Unusable for programming
Category:Implemented
Category:Self-modifying
Category:Output only
Category:2024
Category:Binary
Category:Languages
2 Player

2 Player is a esolang created by User:Yayimhere. its a 2d esolang with two pointers: the data and code pointer. they both move starting going left in the upper left corner of the program. for the data pointer the grid is topologically the same as a donut, but for the code pointer if it goes to the edge it halts
== commands ==
 commands
command	description
^ 	move the pointer up unless its the data pointer
* 	
command	transition
^ 	X
! 	!
x 	X
X 	x
* 	[space]
/ 	\
\ 	/
?  	*
everything else is a NOP
== examples ==
infinite loop(not including the data pointer):
 \
 /x \
 
 ^/ 
 \ x/
 \;
with data pointer:
 \
 x
 /\
 \/
oscillator(at data pointer):
 \/ \
 \^\x
 / \
 x\~/
 / \
 \x/
Category:Languages Category:2024 Category:Two-dimensional languages Category:Unimplemented Category:Unknown computational class
2 Trits, 1 Trybble

2 Trits, 1 Trybble is like 2 Bits, 1 Byte for trinary.
== Commands ==
 00 NOP do nothing
 01 ACT does the same in 2 bits 1 byte
 02 SWI changes 0 to 1, 1 to 2, 2 to 0
 10 JMP jumps to position specified
 11 PRN prints
 12 ACT doese the same in 2 bits 1 byte
 20 JMP jumps to position specified
 21 SWI changes 0 to 1, 1 to 2, 2 to 0
 22 END ends and prints
A cut off one does the N0 version.
== Infinite loop ==
 10010
AKA
 F
Category:Languages Category:Low-level Category:Output only
2 bytes :^)

2 bytes :^) is similar to 3 bytes :v), 25 bytes o: and 16 bytes :P but shorter. By User:Username1234.
==Description==
No matter what program is it it will output the original code.
==Example==
=== Hello, World! ===
 Hello, World!
=== Quine ===
Any code is a quine.
 Even this sentence itself!
==Interpreter==
It's 2 bytes long! written in How to learn this language
 oi
==='Python' is not recognized as an internal or external command, operable program or batch file.===
 ^
Category:Languages
Category:Unusable for programming
Category:Total
Category:Joke languages
Category:Low-level
Category:Output only
2 bytes B)

This is similar to 25_bytes_o: but with 2 bytes.
==Commands==
Any program just outputs itself.
==Cheating Quine==
 QUINE
==Hello World==
 Hello, World!
==Fizzbuzz==
 1
 2
 Fizz
 4
 Buzz
 Fizz
 8
 Fizz
 Buzz
 11
 Fizz
 13
 14
 FizzBuzz
 16
 17
 Fizz
 19
 Buzz
 Fizz
 22
 23
 Fizz
 Buzz
 26
 Fizz
 27
 28
 29
 FizzBuzz
 31
 32
 Fizz
 34
 Buzz
 Fizz
 37
 38
 Fizz
 Buzz
 41
 Fizz
 43
 44
 FizzBuzz
 46
 47
 Fizz
 49
 Buzz
 Fizz
 52
 53
 Fizz
 Buzz
 56
 Fizz
 58
 59
 FizzBuzz
 61
 62
 Fizz
 63
 64
 Buzz
 Fizz
 67
 68
 Fizz
 Buzz
 71
 Fizz
 73
 74
 FizzBuzz
 76
 77
 Fizz
 79
 Buzz
 Fizz
 82
 83
 Fizz
 Buzz
 86
 Fizz
 88
 89
 FizzBuzz
 91
 92
 Fizz
 94
 Buzz
 Fizz
 97
 98
 Fizz
 Buzz
I know this is technically cheating, but I don't care.
==Interpreter==
Written in Inputfish
 oi
Category:LanguagesCategory:Joke_languagesCategory:Unusable for programmingCategory:TotalCategory:Output onlyCategory:Implemented
2 poets, 1 poem

2 poets, 1 poem is a poetic 2 bits, 1 byte.
== commands ==
 1-2 letters - don 00
 3 letters - act 01
 4 letters - jmp 10
 5 letters - end 11
 6 letters - pri (print) 20
 7 letters - inc (increment) 21
 8 letters - dec (decrement) 30
 9 letters+ - only useful for jmp
== endless loop ==
 i wish. the puppy wont stop
== output "m" ==
 yay its a
Category:Languages Category:Unimplemented Category:2024 Category:Low-level Category:Self-modifying Category:Unusable for programming Category:Output only