nyuuzyou/wikis huggingface dataset:
123

123 is an esoteric programming language created by user:David.werecat which further minimizes asdf. 
== Instructions ==
The pointer begins at location 0. The program is executed in a loop, and only terminates if the end of the program is reached and the pointer is below 0. All bits start at the value FALSE. Any unrecognizable characters are treated as NOPs.
Instruction	Description
1 	Flip the current bit and move the pointer left. If the pointer ends at location -4, the pointer is moved to location 0.
2 	If the pointer is at location -3, read a character from the console and put it in locations 0 through 7; then move the pointer to location 0. If the pointer is at location -2, write a character to the console corresponding to locations 0 through 7; then move the pointer to location 0. At any other location, move the pointer right.
3 	Specifies a jump symbol. If the pointer is below 0, do nothing. If the current bit is TRUE, skip back to either the previous jump symbol or the start of the program. If the current bit is FALSE, skip forward to either the next jump symbol or the end of the program.
== Examples ==
=== Cat Program ===
 111212112
=== Hello World ===
 
 222122221212112112112112112112112222122221212112112112112112122222211121121112112121122222221112112111211222222211121111211211222222211121111212222221112111121121122222221112111121222222111211111212112222222111211111222222111111222221111112222221111112222211111222222211211121111122222221121112111122222221112111112121122222221112111112222222111121121112112222222111121121122222211121111211211222222211121111212222221112112111211211222222211121121112122222112112112112111222222112112112112112
Breakdown:
 2221222212121121121121121121121122221222212121121121121121121 // H
 222222111211211121121211222222211121121112112 // e
 2222221112111121121122222221112111121 // l
 2222221112111121121122222221112111121 // l
 2222221112111112121122222221112111112 // o
 222221111112222211111122222211111122222111112 //' '
 2222221121112111112222222112111211112 // W
 2222221112111112121122222221112111112 // o
 2222221111211211121122222221111211211 // r
 2222221112111121121122222221112111121 // l
 22222211121121112112112222222111211211121 // d
 22222112112112112111222222112112112112112 // !
Note : This assumes the characters are read in little-endian fashion. (Least significant bit on memory position 0 and most significant bit on position 7)
== External resources ==
* Visual Basic .NET interpreter and sample programs
* x86 assembly interpreter by User:Bangyen
Category:Languages
Category:2012
Category:Turing complete
Category:Turing tarpits
Category:Low-level
Category:Implemented
Category:Brainfuck derivatives
Category:Cell-based
1231

1231 is a joke programming language created by User:Earthrulerr in C++. You can access a 1231 editor here. 1231 consists of only numbers in its tags, besides printing text. The language is console based, code is inputted into the console and outputted into the console. Every statement must begin with 0 followed by the statement.
== HOW TO USE ==
0 must be used at the start of each statement.
1 followed by '1' or '2', 1 for single word input, 2 to print multiple words to console.
10 prints a new line to console.
20 prints a space to console.
-0 text comment.
111 clears console/restart.
2 # # # + #
-2 # # # - #
4 # # # * #
-4 # # # / #
6 # # # ^ #
8 # input variable (1,2,3,4,5,6,7,8,9,10) = input. EX: 8 1 Hello sets variable 1 to "Hello". Single line only.
9 # prints value of variable (1,2,3,4,5,6,7,8,9,10) to console.
== EXAMPLES ==
0 1 2 Hello, World! Output: Hello, World! 
0 8 1 Hello, 0 8 2 World! 0 9 1 0 10 0 9 2 Output:
Hello,
World!
Sets variable 1 to "Hello," and variable 2 to "World!", then prints variable 1, creates new line, prints variable 2.
0 1 1 A 0 20 0 1 1 cool 0 20 0 1 1 number 0 20 0 1 1 is 0 20 0 4 5 3 Output: A cool number is 15
Category:2022
Category:Joke_languages
Category:Languages
Category:Total
1234

1234 is an extension of 123.
== Instructions ==
The pointer begins at location 0. The program is executed in a loop, and only terminates if the end of the program is reached and the pointer is below 0. All bits start at the value FALSE. Any unrecognizable characters are treated as NOPs.
Instruction	Description
1 	Flip the current bit and move the pointer left. If the pointer ends at location -4, the pointer is moved to location 0.
2 	If the pointer is at location -3, read a character from the console and put it in locations 0 through 7; then move the pointer to location 0. If the pointer is at location -2, write a character to the console corresponding to locations 0 through 7; then move the pointer to location 0. At any other location, move the pointer right.
3 	Specifies a jump symbol. If the pointer is below 0, do nothing. If the current bit is TRUE, skip back to either the previous jump symbol or the start of the program. If the current bit is FALSE, skip forward to either the next jump symbol or the end of the program.
4 	Specified code-jump. Jump right the number of the pointed byte in the code.
== Examples ==
=== Cat Program ===
 111212112
Category:Languages
Category:2017
Category:Turing complete
Category:Turing tarpits
Category:Low-level
Category:Brainfuck derivatives
Category:Cell-based
12345678

12345678 is an esolang invented by User:None1 when he noticed that he didn't invent many Chinese brainfuck equivalents, also because he encountered one of his own brainfuck equivalents by random page.
==Commands==
The commands:
 一二三四五六七八
represent:
 +-<>,.[]
in brainfuck.
==Example programs==
===Cat program===
 五七六五八
===Hello World===
 一一一一一一一一七四一一一一七四一一四一一一四一一一四一三三三三二八四一四一四二四四一七三八三二八四四六四二二二六一一 一一一一一六六一一一六四四六三二六三六一一一六二二二二二二六二二二二二二二二六四四一六四一一六
===Kolakoski sequence===
一一一一一一一七四一一一一一一一三二八四六一六六二六六七二八 ; Print out "12211"
一四四四四一一四四四四一一四四四四一四一四四四一四四一三三三三三三三三三三三三三三三三三三三 ; Store 1 2 2 1 1
 ; s^ f^
一七 ; Infinite loop
 四四二七一四四四四二八一 ; Go to the slow pointer
 三七
 四四二七一四四四四二八一 ; Go to the fast pointer
 四四七四四四四八一一一 ; Set top value to 3
 三三二七一三三三三二八一 ; Go back to the fast pointer
 三三七四四四一四七四四四四八三三三三二三三二七一三三三三二八一三三二八 ; Set top value to 3 minus fast pointer value
 四四四七三三三一四四四二八 ; Restore fast pointer value
 三三三七四四四四八三三三一一一一一一七三一一一一一一一一四二八三六 ; Output top value as character
 四一一一一一一七三二二二二二二二二四二八 ; Restore to number
 二七一三三三三二八一三二 ; Decrement slow pointer value
 八
 四四四七三三三一四四四二八 ; Restore slow pointer value
 三二七一四四四四二八一 ; Go to the fast pointer
 七四四七四四四四八三三一三三三三二七一三三三三二八八 ; Move fast pointer to top
 三二七一三三三三二八一七四四四四一三三三三二八 ; Move slow pointer to the next
 四四二七一三三三三二八一 ; Move back to infinite loop flag
八
==Interpreter in Python==
import sys
def bf(code):
 s=[]
 matches={}
 tape=[0]*1000000
 for i,j in enumerate(code):
 if j=='七':
 s.append(i)
 if j=='八':
 m=s.pop()
 matches[m]=i
 matches[i]=m
 cp=0
 p=0
 while cp<len(code):
 if code[cp]=='一':
 tape[p]=(tape[p]+1)%256
 if code[cp]=='二':
 tape[p]=(tape[p]-1)%256
 if code[cp]=='五':
 c=sys.stdin.read(1)
 tape[p]=(ord(c) if c else 0)%256
 if code[cp]=='六':
 print(chr(tape[p]),end=)
 if code[cp]=='三':
 p-=1
 if code[cp]=='四':
 p+=1
 if code[cp]=='七':
 if not tape[p]:
 cp=matches[cp]
 if code[cp]=='八':
 if tape[p]:
 cp=matches[cp]
 cp+=1
bf(sys.stdin.read())
Category:Languages
Category:Brainfuck equivalents
Category:Implemented
Category:CJK
Category:2024
129

129 is an esoteric programming language by User:TonyBrown148. It is a language with 1 type of data structure, 2 symbols, and 9 operations. In 129 the only valid data structure is stacks, and 129 supports running a 129 program inside one.
129 is Turing-complete, as it can implement SKI calculus, making it a Turing tarpit.
==Language Specs==
===Version Stack===
The version stack is a stack with 3 values that specifies the version of the 129 language. The current version of the 129 language specs is 0.2.0, and the signifing version stack is
 (()(()())())
===Comments===
Any character not a brace is a comment in 129.
===Stack Representation===
A stack is represented using braces. The left brace is at the top of the stack, while the right brace is at the bottom. For example, () represents an empty stack.
===Operations===
Operation Name	Representation 	Explanation
Insert 	((X)) 	Insert X into the stack. The original order is preserved.
Delete 	((())()) 	Pops a value from the main stack.
Duplicate 	((())(()())) 	Duplicates the value on the top of the main stack.
Push 	((()(()))()) 	Pops stack s, pops value v, pushes v into s and pushes s back.
Pop 	(((()()))(()(())))	Pops stack s, pops value v from stack s, pushes v, and pushes s back.
Release 	(((()()))(()())) 	Pops stack s, pushes all the value into the main stack, preserving their original order.
Run 	((((()))())(())) 	Pops stack s, executes the items of s as an 129 program.
Input 	(()((()()))) 	Inputs a character and pushes a stack that contains that number of empty stacks into the main stack.
Output 	(((()()))()) 	Pops stack s from the main stack and outputs the character signified by its size.
===Error Handling===
A 129 program immediately terminates if any command could not be performed. If the current program is executed using the Run command, the run command stops, otherwise the entire program ends.
==Examples==
Users are encouraged to add their own examples.
===Cat program===
 (()(()())()) Version Stack
 ((( Pushes a stack that contains:
 (()((()()))) Input
 (((()()))()) Output
 ((())(()())) Duplicate
 ((((()))())(())) Run
 )( And push the same stack again.
 (()((()()))) Input
 (((()()))()) Output
 ((())(()())) Duplicate
 ((((()))())(())) Run
 )))
 ((((()))())(())) And run the program.
Or, without comments:
 (()(()())())((((()((()())))(((()()))())((())(()()))((((()))())(())))((()((()())))(((()()))())((())(()()))((((()))())(())))))((((()))())(()))
== Interpreters ==
Interpreter written in Node.js by User:Hakerh400.
Category:Languages
Category:2021
Category:Stack-based
Category:Turing complete
Category:Turing tarpits
Category:Implemented
13 bytes :D

13 bytes :D is an esoteric programming language made by User:Esolang1 inspired by 16 bytes :P, which was inspired by 25 bytes o:. The original goal was to create world's smallest compiler/interpreter. 
==Instructions==
Any valid Python expression is a valid 13 bytes :D program. This excludes conditionals and assignment, but the use of lambda allows for arbitrary lambda calculus expressions to be implemented in 13 bytes :D, thus making 13 bytes :D Turing complete. If, instead of 13 bytes :D source code, user input were run, then 13 bytes :D would be ℒ-complete.
==Implementations==
===Python===
The following Python code is the compiler of this language.
 eval(input())
While this is the official compiler, it has an error of floating-point arithmetic.
==Examples==
===1 + 1===
 1 + 1
===i===
 (-1) ** (1 / 2)
===Truth-machine===
 (a:= lambda:(print(1),a()))() if input()=='1'else print(0)
=== Cat program ===
 print(input())
Category:Languages
Category:Implemented
Category:Nested
Category:Joke languages
Category:Esoteric subset
Category:2022
Category:Turing complete
16 bytes :P

16 bytes :P is an esoteric programming language inspired by 25 bytes o: The original goal was to create world's smallest compiler/interpreter. Like 25 bytes o:, all programs in 16 bytes :P are identical.
== Example ==
=== Quine(?) ===
 Anything goes here.
== Implementations ==
=== Python ===
Original Python interpreter:
 print(input())
2 years in I realised this language is 14 bytes, not 16.
Category:Languages
Category:Joke languages
Category:Implemented
Category:Total
Category:Unusable for programming
Category:Zero-dimensional
Category:Output only
16x16 RGB2 panel

16x16 RGB2 panel is a non-turing compete language based on build logic.
== commands ==
=== mode changing ===
 set position mode - default
 increment mode
 & change mode
=== set position mode ===
 + increase value
 } increase color
 - decrease value
 { decrease color
 > brainfuck >
 < brainfuck <
 [ brainfuck [ with value
 ] brainfuck ] with value
 ( brainfuck ( with color
 ) brainfuck ) with color
 , brainfuck , with value
 ; brainfuck , wih color
=== increment mode ===
 + +>
 } }>
 - ->
 { {>
 [ [>
 ] ]>
 ( (>
 ) )>
 , ,>
 ; ;>
== output ==
there are 256 cells.
they are all outputted same time like this:
 abcdefghijklmnopqrstuvwxyz0123456789
 0123456789...
every cell has 256 values. after you get past the value displaying 9, you get... whatevers in build logic!
it wraps after 256
color is 6 bit:
 000 +is 000 +is 000
 000 +is 001 +is 010
the top value is bright rgb (#B00, #0B0, #00B)
the bottom value is dim rgb (#400, #040, #004)
add them together to get F
also this display in 16x16 and starts at top left corner
== implementation ==
build logic on roblox
Category:Languages Category:2024 Category:Cell-based
1=0

Category:Languages 
1=0 is an esoteric programming language based on Forte made to mess up some of the peano axioms that Forte does not.
==Commands==
In 1=0, the main action is to assign new values to numbers, but it is possible to use the arithmetic assign operators (+=, -=, *=, /= and %=).
Also, using { and }, it is possible to create codeblocks, one of which are assigned to a number. Then, when that number is used, it would run its code instead. A code block can have a return value, which is assigned using =<return value>. If not specified, the return value is 0.
Finally, for I/O functions, ; gets a number from user input, ? gets a character from user input then returns its ASCII code, : prints the value at its right as a number, and ! prints the value at its right as an ASCII character.
Command	I/O Feature
; 	Numeric input
? 	ASCII input
: 	Numeric output
! 	ASCII output
==Breaking the Peano Axioms==
* 0 is a natural number.
 0 -= 1
* Natural numbers have successors.
 1 = 0
* a and b compart successor if and only if a = b.
 5 = 0
 8 = 0
:This works because if a > c and b > d then a + b > c + d so 4 + 4 > 3 + 2.
* No natural number is a predecesor of 0, because negatives are not natural numbers.
 0 = 2
* A list with 0, the successor of 0, the successor of the successor of 0, and so on contains all the natural numbers.
 3 = 0
==Examples==
===Hello World===
 !72
 !101
 !108
 !108
 !111
 !32
 !87
 !111
 !114
 !108
 !100
 !33
===Chr Cat===
 !?
===Num Cat===
 :;
===Calculator===
 55586=;
 55587=;
 55588=?
 88843={
 55586+=55587
 }
 88845={
 55586-=55587
 }
 88842={
 55586*=55587
 }
 88847={
 55586/=55587
 }
 88837={
 55586%=55587
 }
 905050=88800
 905050+=55588
 :55586
===Truth Machine===
 4567=;
 5431={
 :1
 905050=5431
 }
 675434=5430
 675434+=4567
 :0
1BNWL

1BNWL(1-Bit Non-Warpping Language) is variant of Brainfuck with 1-bit tape invented by User:ChuckEsoteric08 in 2022.
==Commands Changed==
+ will set current cell to 1, and - will set current cell to 0 and , is deleted.
==Goals==
*Creating language that is easy to implement
==Computational class==
It is Turing-complete as long as tape is unbounded. It's proven by translation from Smallfuck:
 > - >>
 < - <<
 * - >+<[->-<]>[<+>-]<
 [ - [
 ] - [
==See also==
*Brainfuck minus -
==External resources==
Implemented in go by User:Nmcassa
Category:Languages Category:Turing complete Category:Turing tarpits Category:Brainfuck derivatives Category:Implemented Category:2022 Category:Cell-based Category:Low-level Category:Output only
1Fish

1><> (pronounced as "one fish") is a stack-based programming language based on Fish.
==Overview==
1><> is a 1-dimensional version of ><>. Its functionality is mostly the same, however some commands are altered.
===Execution===
Rather than a 2D playfield, it uses average style of writing programs, 1D. Because of this, there are no instruction pointer direction changes. The instruction pointer still exists, however it will not loop around at the end of the program, thus not needing an end program command. Any input is provided at the start, using the -i flag along with all the inputs. (e.g. ./1fish.py file.1f -i 43 2 7)
===Stack===
The stack can only contain numbers.
==Commands==
Any character that isn't valid will just be skipped. Space is a NOP.
===Input, output, and arithmetic===
0-9 	Push the number onto the stack
+ - * / | ^ %	Pops x (topmost) and y (second) and pushes y (operator) x. | is floor division (does division but ignores the remainder), ^ is exponent, and % is modulo (does division but returns only the remainder).
o 	Pop and output the Unicode character of the top item. If it's a decimal, round it.
n 	Pop and output the number of the top item (e.g. having 65 in the stack and using n will output 65, not A. Using o will do the opposite.)
i 	Take one character input, and push its value as a number. If no input is provided, push 0. (e.g. Code: in >> Input: A >> Output: 65)
" 	Toggle string parsing. If string parsing is enabled, push every characters' Unicode value onto the stack until disabled. This only works with double quotes.
===Comparisons===
< = >	Pop x and y off the stack, and push 1 if y (operator) x is true. Push 0 otherwise.
===Stack-based===
Commands that revolve around the stack.
l 	Push the length of the stack onto the stack
d D	Duplicate the top item or the whole stack, respectively.
c 	Remove the whole stack
r 	Reverse the stack
q 	Pop and discard the top item of the stack
s 	Swap the top 2 values of the stack
===Conditional branching===
{ }	Runs the code inside of the 2 braces only if the top item (which gets popped) is non-zero. If the stack is empty, jump to the corresponding }. (Procedure: When the IP hits {, it will find the corresponding }. It will then pop the top value. If it's 0 or the stack is empty, jump to the }, otherwise, proceed inside.)
j 	Pop x and jump to position of x - 1 in your code. In other words, jump to AND RUN the command at position x.
( )	Repeat the code inside until the stack is empty, essentially creating a loop. Checks if the stack is empty at the end of the loop. If the stack is empty to begin with, skip everything inside.
==Examples==
===Hello, world!===
 "Hello, world!"r(o)
 >> ./1fish.py helloWorld.1f
 Hello, world!
==Interpreters==
===1fish.py===
The one written by the author. Download will be up when it's actually done. 
Category:Languages Category:Stack-based
1Hash

1# is a 5 instruction register machine language. 
Add 1 to Rn	Add # to Rn	Go forward n	Go backward n	Cases on Rn
1n# 	1n## 	1n### 	1n#### 	1n#####
Registers are processed as queues: first in, first out.
All numbers are written in unary.
The first two types of instructions add symbols to the right ends of the registers.
Case instructions pop symbols from the left ends. They work as follows:
* If Rn is empty, we go to the very next instruction.
* If the first symbol of Rn is 1, delete it and count down two instructions.
* If the first symbol of Rn is #, delete it and count down three instructions.
Instructions are sequences of 1s and #s, and programs are sequences of instructions.
In the interpreter, spaces inside of instructions don't count.
You may enter each instruction on a line of its own, and you also may skip lines.
Alternatively, a program may look like a long sequence of instructions run together. 
When treating # as 0, each program is its own Gödel number.
Implementations are offered by the language designer in Java, as well as r5rs and r6rs scheme.
==Computational class==
1# is Turing-complete, even if only a single register is available. The easiest way to show this is probably via simulation of DownRight; change each cell of the (finite) program into a sequence of commands that push to the register, then shift from the register and go down (i.e. jump to the code that was compiled from the cell below) if a 1 was popped or right if a # was popped.
==External resources==
*Paper (PDF) describing 1#
Category:LanguagesCategory:Computational modelsCategory:Queue-basedCategory:Turing completeCategory:No IOCategory:ImplementedCategory:Low-level
1L

Though Gregor Richards purported 2L as a Turing-complete language with only two operators, the nop operator (that is, anything that's not + or *) is so significant in 2L that it serves as a third. 1L is a family of attempts to reduce the set of symbols even further, producing a two-dimensional language that truly only has two symbols (the name being a perverted joke against 2L: since 2L has 3 commands, 1L has 2 commands).
Several versions of 1L have been proposed and implemented:
* 1L_a, which is fairly pure to the spirit of 1L.
* 1L_AOI, which uses angle-of-incidence to choose actions.
* Black, which was inspired by 1L and BackFlip.
* Wunnel, which combines ideas from 1L with those from turning tarpits.
* Turnfunge, Nopstacle and Turn Left, which increment/decrement counters as the instruction pointer wraps.
==See also==
* 2L
* Wierd distinguishes only between whitespace and non-whitespace symbols.
Category:Languages
Category:Implemented
Category:Unimplemented
Category:Two-dimensional languages
Category:Turing tarpits
Category:Low-level
Category:Non-textual
Category:2005
1 1

1 1 is just basically just Ебаное дерьмо but in binary 
== change ==
all russian is 1 and o for english. thats it. nouns must have 2 added while for verb its a 4
== examples ==
Infinite loop:
 1, 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 12, (1),
Category:Languages Category:2024 Category:Stack-based
1 Bit, a quarter byte

1 Bit, a quarter byte is an assembly language for a 1-bit CPU, made by User:None1. With 1/4 byte of memory, this machine could store 2 instructions.
==Commands==
Command	Name	Meaning
0 	END 	END. Print the entire memory as bits and end the program.
1 	INT 	INverT. Invert the other bit.
The instruction pointer can wrap around, thus allowing more "complicated" programs.
==Examples==
===All possible programs===
 00 -> 00
 01 -> 01
 10 -> 01
 11 -> 10
===Quine===
 00
Another one:
 01
==Interpreter in Python==
print({"00":"00","01":"01","10":"01","11":"10"}[input()])
Category:2023
Category:Implemented
1 Line Challenge

The 1 Line Challenge is a challenge started by Scratch-Minion in 2016. The objective is to create images defined in 1 line of code in Scratch.
== Description ==
Examples are remixed from the original Scratch "project". Images are drawn from left to right and down to up, with the pen size set to 2 due to a bug in Scratch 2.0 that causes gaps in the image if the pen size is set to 1. The default resolution is 360x360, but the image can be expanded to fill the entire 480x360 canvas by modifying the Draw Row custom block to repeat 480 instead of 360 times and accordingly adjusting the x position from -180 to -240. The final image is expected to be used as the thumbnail. It can be generated using either of the two available "set pen color to" blocks:
* The first features a range of rainbow colors, and is stated by the author to be easier. The Scratch 2.0 version supports rainbow colors from 0-200, while the Scratch 3.0 version dropped the maximum to 100 and added options for saturation, brightness and transparency, none of which are allowed.
* The second allows for much more colors. The color has to be "picked" from the screen in Scratch 2.0, while Scratch 3.0 also allows for individually set "CSB" (Color Saturation Brightness) colors. This system is similar to HSV (Hue Saturation Value), but reduces the maximum color value from 0-360 to 0-100 due to limitations, while the other values remain at 0-100.
There are two official studios, the second of which, Not Quite a 1 Line Project, is for projects using additional blocks. 5 projects per user can be added per day unless the patterns are considered "nice". Images are specifically stated to be required to use more than 1 color, and not solely use a random number generator.
== Sample programs ==
The original template is preloaded with the following sine wave example. The x and y position perimeters can be found in Motion, and the rest in Operators. As Scratch is a visual language, the example is presented here in Tosh, a text-based adaptation of Scratch. 
 180 * sin of x position - y position
== External links ==
* Original template
* RGB image
* 1 Line Challenge Favourites (only features screenshots)
* Official studio
* Not Quite a 1 Line Project
Category:Program forms
Category:2016