nyuuzyou/wikis huggingface dataset:
401

401 is a very simple esolang made to be turing complete and have less commands than nope. oh also it was made by User:Yayimhere
== syntax ==
there are 4 commands:
 xy will set x to the binary signed number y
 xyz set x to y plus z. y and z can only be variables
 x: if x is less than or equal to 0 do the following command(s) until ;(which separates comands). else do nothing
 x goto line x
== examples ==
count down from 99 to 0:
 x01100011
 y11
 xyx
 x:
 10
== computational class ==
notes:
* numbers are signed binary numbers 
* - and + are reserved registers for dec and inc
* every register must be created using name value without the space
* this uses Short Minsky Machine Notation
this is the translation:
 ℘xy
 |
 V
 y-y;y:x+2
 -
 ℘y
 |
 V
 y+y
and the program must start with:
 +01
 -11
Category:Languages Category:Turing complete Category:Turing tarpits Category:No IO Category:Unimplemented
42

42 is a Gödel numbering language, or set of languages, where the self-interpreter is represented by the number 42.
==Bootstrapping==
Input the number 42 into 42, then input any other number to have it execute the corresponding 42 program.
==Properties==
Not all numbers are necessarily cleanly executable as 42.
42 (when discovered) is necessarily Turing complete.
There may be many 42 languages to discover.
==Examples==
===Self-interpreter===
42
==Practical implementation==
Even though this is a joke-language, where the joke is that a Turing complete language can bootstrap itself ex-nihilo from its Gödel number if the program represented by that number is a Turing complete language self-interpreter which contains a Gödel number mapping that ensures the value of its own code is 42 (similar to how Quines are constructed), it is nevertheless possible to implement.
===Suggested procedure===
* Start with a bf self-interpreter
* Modify it so that it accepts Brainfoctal like Gödel numbers as input and converts to bf to execute
* Add bf code which maps the number 42 to the Brainfoctal value of itself + resulting interpreter
Trivial examples:
{mapped Gödel number} = 42 - {input program's Brainfoctal value} + {interpreter's Brainfoctal value}
{mapped Gödel number} = 42 if {input program's Brainfoctal value} == {interpreter's Brainfoctal value},
 {interpreter's Brainfoctal value} if {input program's Brainfoctal value} == 42,
 else {input program's Brainfoctal value}
or some other more or less silly transform.
* Adjust by iteration / experimentation so that the resulting Gödel number is still 42
The result will be a bf program that executes 42 Gödel numbers. Feeding it 42 executes an identical program in 42 that accepts and executes 42 programs (which will be Gödel encoded bf, in this implementation).
===Example===
The implementation here is a 42 done in a slightly different way. It takes the base-9 digits of the source number as symbols of a language that consists of brainfuck plus an eval that takes the number in the current cell and runs it as 42 code, such that the number 42 (written '46' in base 9) corresponds to the program ,e.
==Implications / Speculation verging on the mystical==
There is possibly something profound hidden in this joke, that may explain how anything exists. Numbers can encode systems to self-interpret themselves and every other possible algorithm, because: mathematics... woo!
Alternatively, information theory may provide some insight into how the 6 bits 101010 is not sufficient to store a self-interpreter for a Turing complete programming language...
Category:2018 Category:Joke languages Category:Implemented Category:Languages
4BOD

4BOD, or alternatively 4 Bits of Doom is an esoteric fantasy console and machine language made by puarsliburf games for the FC Dev Game Jam in 2017. It parodies the style of other 8-bit style Fantasy Consoles such as Pico-8 and Tic-80 by having extremely low "specs". 
== Specifications ==
4BOD is said to have 0.384 kilobytes of program memory, 0.008 kilobytes of RAM and 0.032 kilobytes of VRAM. Programs are created by drawing a black and white image in the built in editor representing 1s and 0s of machine language. It uses 4 bits for the 16 opcodes each with 0-2 4 bit operands. 
The Screen is an 16x16 1bpp pixel grid each controlled by 1 bit in the 256 bits (32 bytes or 64 nybbles) of VRAM. The Program is represented as 16 12x16 pixel 1bpp images. 4BOD can address 16 unique memory addresses each with 4 bits of data (Storing a number from 0-15) in addition to a single 4-bit accumulator.
The original implementation seems to be bugged to the point of (more than intended) unusability. The original developer said they lost the source code so it will likely remain unfixed. So use an open-source reimplementation if you want code where bugs can be fixed.
== Instructions ==
 0000 - Do nothing.
 0001 arg1 - Sets the accumulator to the value stored at the address arg1. 
 0010 arg1 - Writes the accumulator to the address arg1. 
 0011 arg1 - Sets the accumulator to arg1. 
 0100 - Sets the accumulator to the states of the arrow keys in the order D|U|R|L.
 0101 - Increments the accumulator, overflowing if it goes above 15. 
 0110 - Clears the screen. (setting all VRAM to 0)
 0111 - Shifts the accumulator left.
 1000 - Shifts the accumulator right. 
 1001 arg1 arg2 - Sets the accumulator to the state of the pixel at the X and Y coordinates of the values at addresses arg1 and arg2,
 respectively. 
 1010 arg1 arg2 - Flips the state of the pixel at the X and Y coordinates of the values at addresses arg1 and arg2, respectively. 
 1011 arg1 - Creates a flag named arg1. 
 1100 arg1 - Jumps to the flag named after the value stored at the address arg1. (If 2 flags have the same ID the one later in the code
 is the one jumped to)
 1101 arg1 - Only perform next instruction if the value at address arg1 is equal to the accumulator.
 1110 arg1 - Only perform next instruction if the value at address arg1 is greater than the accumulator.
 1111 arg1 - Only perform next instruction if the value at address arg1 is less than the accumulator.
All arguments are 4 bits and can have a value of 0 to 15. The program is called every frame and endless loops within the code freeze 4BOD.
== Examples == 
=== Display a 2x2 Square in the center of the screen. ===
In binary form:
 0110
 0011 1000
 0010 1000
 0011 0111
 0010 0111
 1010 1000 0111
 1010 1000 1000
 1010 0111 0111
 1010 0111 1000
In image form:
=== Truth Machine ===
== External Links == 
Original itch.io page 
A re-implementation in Python3 
Category:Languages
Category:Low-level
Category:Implemented
Category:Non-textual
Category:2017
Category:Bounded-storage_machine
Category:Usability_unknown
4DL

4DL, which stands for 4 Dimensional Language, is an esoteric programming language designed by Cliff L. Biffle. 4DL programs exist in four-dimensional space. They are based around a single stack.
An interpreter, written by Bernhard Stoeckner, is available. See external resources.
==External resources==
* 
* 
Category:Languages
Category:Stack-based
Category:Multi-dimensional languages
Category:Implemented
Category:2001
4Head

4Head (pronounced "fore•head") is a brainfuck-inspired programming language.
The additions on top of brainfuck are: there is now a register called "hold", which holds a cell value and is the only value that can be directly operated upon. Memory is operated upon by loading a cell from memory into the hold register, doing an operation, and putting the value back into memory.
In the source code, if a decimal number 'N' comes right before a +/- instruction or a </> instruction,
then that instruction is done 'N' times. This is just a shortcut for compact programs.
Also, the main memory is layed out as 2D (but the program text is still a 1D sequence of characters).
The memory cells could be of any size, but 16-bit 2's complement integers are good.
Non-command characters should be ignored and not cause errors.
== Correspondence with brainfuck ==
Any brainfuck program can be rewritten into an equivalent 4Head program.
One straightforward way of doing this is by doing the following for each +/-/./, instruction:
# Insert a @ before it
# Insert a ! after it
This means that 4Head is a superset of brainfuck, thus it is Turing-complete.
== Instructions ==
 Instruction table
Instruction character	Program effect
> 	move right in memory
< 	move left in memory
^ 	move up in memory
v 	move down in memory
+ 	increment hold
- 	decrement hold
@ 	"fetch" - write current value in memory into hold
! 	"store" - write current value in hold into memory
% 	swap hold value with currently selected memory value
? 	read input into hold
. 	write output from hold
[ 	loop begin using hold
] 	loop end using hold
== Hello world program ==
 Hello, world!
 @8+![#>@4+![>@2+!>@3+!>@3+!>@+!4<@-!@]>@+!>@+!>@-!2>@+![<@]<@-!@]2>@.>@3-!@.@7+!@.@.@3+!@.2>@.<@-!@. 
 <@.@3+!@.@6-!.@8-!@.2>@+!@.>@2+!@.
== Implemenations ==
* The author has implemented an interpreter: 4Head/AuthorImplementation.c
Category:Languages
Category:2023
Category:Implemented
Category:Brainfuck derivatives
Category:Turing complete
4ME

4ME is possibly a programming language created by User:Ractangle that has two (three if you count the scraped rewriten version) versions
=Normal 4ME=
This is basically the 4ME before the planned rewrite of the language
==Commands==
Command 	It's action
P; 	Starts the program
out{...} 	Prints a string
is 	Gets string input and pushes it to the stack
ns 	Same thing as but uses number input
add{...} 	Pushes a value to the stack
pop 	Pop's element from stack
get 	Prints a element on the stack and pop's the element
+,-,*,/ 	Operators
duplicate	duplicate the top value on the stack
store 	Moves element from the stack to the other stack
unstore 	the opposite of
==Errors==
The action to error 	Stop Code
Not having any code in the line at all 	S1456
Outputing variable v without seting it to a value	S3452
No P: at the start of the file 	S1245
==Examples==
===Hello, world!===
 P;
 out{Hello, world!}
===Cat program===
 P;
 is
 get
===A+B Problem===
 P;
 ns
 ns
 +
 get
=Rewritten 4ME=
This version of 4ME is in progress and will take some time on actually completing it
==Arguments==
Argument name	Action
s 	Alowes a program to be used in a server
d 	Debug infotmation
==Commands==
Command 	Action
echo{...} 	Prints a string in the brackets. Prints the top value in the stack if the contents is
var{...=...} 	Creates a variable
echo.var{...}	Prints a variable
#... 	Comment
user 	Gets user input. Cannot be used as a seprate command
push{...} 	Pushes a string in the brackets to stack
==Examples==
===Hello world===
 echo{Hello, world!}
===Cat program===
 var{_=user}
 echo.var{_}
=Scraped 4ME=
By "scraped", i mean that this was a scrpaed rewrite of 4ME
==Commands==
Commands 	Action
[ ... ] 	Comment
out[ ... ]	Print's the contents
=See Also=
* The interpreters
* 4ME on Rosetta Code
* Offical 4ME wiki (or 4WIKI)
Category:LanguagesCategory:2024Category:Queue-basedCategory:Implemented
4RL

4RL (pronounced "for real") is an esoteric programming language created by User:Frogstair in April 2020, and is a breed of brainfuck.
The language can be compiled to brainfuck in a 1:1 relationship if the A command is not used.
== Language overview ==
4RL, like brainfuck, operates on a tape, each cell in the tape is initialized to zero. The tape is 2^16 bytes long, each cell being one byte.
The commands are equivalent to brainfuck:
Command	BF equivalent	Result
4 	+ 	Increment tape cell at pointer
r 	- 	Decrement cell pointer
e 	> 	Advance pointer to next cell
a 	< 	Retreat pointer to previous cell
l 	[ 	If value under pointer is zero, jump to matching L
R 	, 	Take user input, store it in the cell under pointer
E 	. 	Output value under pointer as ASCII character
A 	None 	Terminate program
L 	] 	If value at pointer is not zero, jump to matching l
== Examples ==
=== Hello, World! ===
Here is a hello world program
 44444444le4444le44e444e444e4aaaarLe4e4eree4laLarLeeEerrrE4444444EE444EeeEarEaE444ErrrrrrErrrrrrrrEee4Ee44E
===Cat Program===
This cat program is repeated until the user inputs the null character:
 RlERL
===Truth-Machine===
The following serves in the definition of a truth-machine:
 RElrre4leeLalELaaL
===Program Termination===
This example demonstrates the program termination instruction A by printing the letter “B” once, but obviating its iterum output via an intermediate halt command:
 444444444444444444444444444444444444444444444444444444444444444444
 EAE
==Interpreter==
* Common Lisp implementation of the 4RL programming language.
Category:Languages Category:2020 Category:Brainfuck derivatives Category:Implemented
4 bits, unlimited bytes

4 bits, unlimited bytes is an assembly language invented by User:TheBigH. It is inspired by 4 bits, 8 bytes.
== Changes ==
4 bits, unlimited bytes is identical to 4 bits, 8 bytes, except for the following:
* 4 bits, unlimited bytes has infinite memory. It can still wrap around if the memory pointer somehow reaches infinity. Programs are still a finite number of characters, however after all of the characters, the memory is filled with ○. Example: ExampleProgram becomes ExampleProgram○○○○○○○○○○○○○○○○○ with ○ repeating forever.
* Instruction 1101 (OUT) no longer takes the modulo 8.
* Instruction 1110 (OUB) only outputs the first 8 bytes.
* Addresses are now represented with the system below.
== Addresses ==
If the address is 3 bits long or fewer, it is represented by 0(address). Example: 0101 refers to byte 5.
If the address is 6 bits long or fewer, it is represented by 1(first 3 bits)0(last 3 bits). Example: 11010010 refers to byte 42.
If the address if 9 bits long or fewer, it is represented by 1(first 3 bits)1(next 3 bits)0(last three bits). Example: 111010100000 refers to byte 400.
This system continues forever.
Category:Joke languages
Category:Low-level
Category:Unimplemented
Category:Self-modifying
Category:Output only
Category:2023
Category:Languages
Category:Binary
Category:Usability unknown
4 esolang + Python polyglot

The following is a polyglot created by User:None1, it outputs Hello, World! in Befunge, brainfuck, Deadfish~, oOo CODE and the non-esoteric language Python.
==Language parts==
The highlighting shows the major part that is executed for each language.
* brainfuck part
* Befunge part
* Deadfish~ part
* Python part
* oOo CODE part
* Hello, World! string, used by Python and Befunge
==Program==
 #> vwh
 print("""
 [@,,,,,,,,,,,,,"Hello, World!"<
 ]++++++++[>++++++++<-]>++++++++.>++++++++[>++++++++++++<-]>+++++
 .+++++++..+++.>++++++++[>+++++<-]>++++.------------.<<<<+++++++++++++++
 .>>.+++.------.--------.>>+.[-][sCKRmICkEVlDPaKIrGAjYEpMUqVnDdvvoXrKZzUEkBCpKYv
 XQnMFyENzJkpYShnkEFvspEwREwYYcUJoQHbDAxKHsNPfVGArbrbZwTCnYFuYWoVVzBTsGFiTNyA
 sSlujtUxSYqQFdBSbVFlAGqYKwJKgOJgOUzZExFRlGeoAAnrqYBvpyMgMIoHKfVTkYOuSVOqTaZX
 aLPyWEjMBnQIbLFwGFGyPFcYuGLwDUuMLMcfkqVsVIpOSsTPmNGgSCiDDaLIuEsGbyalOrMAmWHw
 RMkXSqNcbBKzlfYDghuOyRAjEHiEKvWIFsAlbTlkTjfOsaUkwDjsLrvNygOslAipAaoSgtIVylkM
 fqJxyKmnTPpFNzFZlHXqWKqVSsBCvEOmZMjVFuHTgRKwWEvXGzNWeVRKclbrcofMTgHaDPfRYsHQ
 PnRwuKdiAciFgxSvxUukLLdEwqJjiFlhBhaOhfFgmWldSraAXzaolwvcDcBCDu
 """[23:36],end=""+0*"]")
==External Resources==
* Try it Online (Python)
* Try it Online (brainfuck)
* Try it Online (Befunge)
* Try it Online (oOo CODE)
* Try it Online (Deadfish~)
* Interpret Esolangs Online (brainfuck)
* Interpret Esolangs Online (Befunge)
* Interpret Esolangs Online (oOo CODE)
Category:Examples
4cell

4cell is an esoteric programming language developed by User:Legoninjaenoch. Its name comes from the four cells that can be manipulated with commands. They are a, b, c, d. They can be increased, decreased, added, subtracted, cleared, copied, randomized, and printed. 
=== Commands ===
Command	Description
a 	Increase cell a by 1
b 	Increase cell b by 1
c 	Increase cell c by 1
d 	Increase cell d by 1
A 	Decrease cell a by 1
B 	Decrease cell b by 1
C 	Decrease cell c by 1
D 	Decrease cell d by 1
> 	Copies the value of a cell into another.
! 	Clears a cell.
? 	Sets cell to random number 1-144.
+ 	Adds two cells and stores number in specified cell.
- 	Subtracts two cells and stores number in specified cell.
. 	Prints number in cell.
, 	Prints ascii equivalent of number in cell.
( 	Starts loop, the number in the cell written after it is the number of times repeated
{ 	Marks beginning of command to be looped
} 	Marks end of command to be looped
Use lowercase letter when referencing a cell.
You can put spaces between commands but not between a command and its arguments.
Yes: >ab a b +abc
No: + a bc >b c
=== Examples ===
Loop 
Increase a to 4 then start a loop that will be executed a times and the command to be executed is b.
aaaa(a{b}
Addition: 
Increase a and b to 2 then add them and store in cell d.
aabb+abd
Copy/Move: 
Increase c to 3 then move the value of c into d. they both contain the number 3 now.
ccc>cd
HELLO WORLD
Prints hello world in all caps.
aaaaaaaa(a{aaaaaaaa},a>abAAA,abbbb,b,bbbb,bcccc(c{ccccccc},c>bddddddddd,d,bbbb,bBBBBBB,bA,a
Category:Languages
Category:2022
Category: Cell-based
Category:Unusable for programming
Category:Total
Category:Implemented
5

5 is an esolang by User:Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff that is based off the simple fact that 1 = 5. Some programming languages such as Forte support this functionality, but 5 dials it up to 55. Every digit 1 is replaced by the digit 5, even in the program counter. It contains an accumulator, however it also has a queue and a control stack.
== Commands == 
 Commands
Command	What it does do
number 	set accumulator to number
« 	digitwise left shift by 1 (decimal)
» 	digitwise right shift by 1
+ 	increment accumulator
² 	square accumulator.
³ 	cube accumulator
! 	skip next command if accumulator is 0
? 	Enqueue the accumulator
- 	decrement accumulator
{ 	push the pc on the stack
| 	pop the stack
} 	pop the stack and jump to it
~ 	bitwise not
[ 	jump to matching ]
* 	rotate queue left
^ 	rotate queue right
, 	count the 5's in the accumulator
; 	skip next
If the accumulator is less than 0, dequeue the top element and set to the accumulator.
== Variants ==
=== 15 ===
15 (or 55) is just 5 with I/O and comments
Comments are in parentheses.
comments are removed before executing
`string` prints out string.
`` prints a newline
 # output number
 @ input
 $ output char
=== 35 ===
35 is 15 without the 1 = 5 Rule.
Backslashes apply the 1 = 5 rule for one instruction.
== Programs ==
=== Hello, World! ===
==== 35 ====
 `Hello, World!`
=== Truth-machine ===
==== 15 ====
 ;_@{#!}
==== 35 ====
 @{#!}
== Computation class ==
You can compile ALWCIDFEC into 5, so 5 is turing complete.
Start with ???
=== Cell-based instructions ===
+ ::= «+
* ::= *«+^
4 ::= ^«+*
- ::= »
/ ::= *»^
1 ::= ^»*
==== 15 & 35 ====
Since 15 and 35 are supersets of 5, they are turing complete as well.
==== Loops ====
brackets can be made like this:
!;[{code!}|;]
== Categories ==
While 5 has no IO, 15 and 35 do.
Category:Turing complete
Category:No IO
Category:2024
Category:Implemented
Category:Stack-based
Category:Queue-based
5-logic

== Description ==
 +-------+ Adjacent Opposite
 | | ! @% #$
 | ! | @ #! $%
 | % @ | # $@ %!
 | $ # | $ %# !@
 | | % !$ @#
 +-------+
A value can be:
* 5-value: one of ! @ # $ %
* List: list of zero or more values inside square brackets. For example: [![Zero@@]{2_0_Take}]
* Variable name: Name of a variable, first letter uppercase rest lowercase (only letters).
* Program code: A program code with curly brackets. Use semicolons to separate commands. Example: {A=!;B=%;2AB}
Commands:
* value - Return this value from this function
* var=value - Set a value of a variable
* \name - External system function
* /*comment*/ - Comment
* -var - Makes a new variable local to this block of program code and sub-calls
* --var - Same as above but initial value is argument of this function-call.
* value:code - For each element in list(value), execute code, element is argument, return value exits loop and returns from parent code. (Error if value is not a list or the name of a variable containing a list)
* ?value - Return this value from the function if previous line changed a value of a variable to a 5-value adjacent to its previous value. (Error if either value isn't a 5-value. Even error if new or old value is a variable name.)
Operators:
* 2xy - 2-logic on values. 2-logic on adjacent values = common opposite value. 2-logic on opposite values = common adjacent value. 2-logic on 2 same values = value.
* 3xyz - 3-logic on values. 3-logic on xyz = (x if x=2yz, y if y=2xz, z if z=2xy). 3-logic on xxy = y. 3-logic on xxx = x.
* `xy - Apply function x to argument y.
* +xy - Concatenate 2 lists.
* ^x - Include contents of a list inline. Example: 2^[!%] --> 2!% --> # and [!2^[###]!] --> [!2###!] --> [!##!]
* 0 - Uses argument of this function.
* 1 - Uses argument of parent function.
When evaluating parameters to 2 or 3, convert variable names to their values. If one or more parameters is a list, they must all be of the same length, then iterates through list in order using non-lists as well. For example: 2[ab]c = 2[ab][cc] and 3[[!@]$][%[$]]% --> [[3!%%3@%%][3$$%]] --> [[!@][%]] (If variables are undefined or lists of not matching size, or are program codes, then is error.)
For ^ and + commands, variable names are converted to values of variabled. Errors if 5-value or program-codes or undefined variabled.
For ` command, the function x is converted to its value if is a variable name. If x is a 5-value or a list or undefined variable, then is error.
== Examples ==
If you want to use binary functions, and you use !=1 and @=0 then you can do:
 NOT x = 22x$$
 x XOR y = 3xy@
 x AND y = 2!`{320$20@0}2$2xy
 x OR y = 2@`{320$20!0}2$2xy
For example:
 Not={220$$};
 A=`NotB;
Category:Languages
Category:2007
Category:Unimplemented
5050BrainF

5050BrainF is an esolang made by User:Joe, which is just Brainfuck but the commands + - < > have a 50% chance of doing their function or doing nothing.
==Determinism==
Many programs are not deterministic and are impossible to predict the output, but since loops always work normally, along with IO operations, some programs are deterministic.
==Examples==
Demonstrating the randomness:
C:\factor-0.99\factor\5050brainf>type test.bf
"++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++."
C:\factor-0.99\factor\5050brainf>.\5050brainf test.bf
↔
C:\factor-0.99\factor\5050brainf>.\5050brainf test.bf
+
C:\factor-0.99\factor\5050brainf>.\5050brainf test.bf
%
C:\factor-0.99\factor\5050brainf>.\5050brainf test.bf
▼
C:\factor-0.99\factor\5050brainf>.\5050brainf test.bf
$
C:\factor-0.99\factor\5050brainf>.\5050brainf test.bf
↓
C:\factor-0.99\factor\5050brainf>.\5050brainf test.bf
"
C:\factor-0.99\factor\5050brainf>
Some deterministic programs:
Skip rightwards to an empty cell
[>]
Skip leftwards to an empty cell
[<]
Clear current cell
[-]
==Computational class==
The computational class is currently unknown. It is likely to be arbitrarily Turing complete. That is, if given some probability p, there is likely a way to convert an arbitrary Brainfuck program into a 5050BrainF program which gives the correct result with a probability matching or exceeding p. No known method of doing this exists, but likely will rely on the determinism of loops.
==Implementations==
* 5050BrainF interpreter in the Factor Programming Language
Category:Implemented
Category:Languages
Category:Unknown computational class
Category:Probabilistic
Category:Cell-based
Category:2024