nyuuzyou/wikis huggingface dataset:
Mini-Flak

Mini-Flak is a derivative/minimisation of Brain-Flak, created in 2016, most likely by User:Wheatwizard.
== Specification ==
Mini-Flak's main storage is a stack of unbounded integers (which can go negative). The stack is initially an infinite stack of the number 0.
Mini-Flak has two sorts of commands: nilads and monads. A program as a whole is just a list of commands, which are executed in sequence when the program is run.
Nilads are commands that take no arguments; when executed, they possibly change the stack, then return an integer. There are two nilads:
* (): Always returns 1.
* {}: Pops the stack, and returns the popped value.
Monads are commands that refer to a nonempty list of other commands (sort-of like blocks in other languages). The monad is written as a pair of grouping characters with the other commands it refers to placed inside the monad (e.g. (()()) is a (…) monad which refers to two () nilads). The commands referred to by the monad are not automatically executed when the monad is (although most of the time, the monad will execute them as part of its effect). Just like nilads, monads will do something when executed (possibly changing the stack), then return an integer. There are three monads:
* (…): Execute all the referred-to-commands, adding together their return values. Push the resulting sum of return values onto the stack, and return it (in addition to pushing it onto the stack).
* […]: Execute all the referred-to-commands, adding together their return values. Return minus the resulting sum of return values. (This command does not directly change the stack, although it may change it indirectly as a consequence of executing commands that change the stack.)
* {…}: If the top element of the stack is 0, do nothing and return 0. Otherwise, execute all the referred-to commands, adding together their return values, then execute this {…} command again, adding on its return value. Return the resulting sum of return values. (For example, if there are three 2s on top of the stack and the rest of the stack is zeroes, {{}} will pop the stack three times and return 6.) Just like […], there are no changes to the stack beyond those made by the referred-to commands.
In addition to writing commands, some implementations allow comments, which go from # to the end of the line. Invalid uses of the ()[]{}<> characters are undefined behaviour. Other invalid characters are typically ignored.
Most Mini-Flak implementations output the final state of the stack when the program finishes executing, either interpreting it as ASCII characters / Unicode codepoints, or in decimal (sometimes with an option to choose).
== Computational class ==
Mini-Flak is known to be Turing complete. The usual proof involves simulating a counter machine.
== Example ==
Here's a program fragment that swaps the top two elements of the stack:
 (({}({}))[({}[{}])])
== Implementations ==
Mini-Flak is a strict subset of Brain-Flak, and thus is normally implemented using a Brain-Flak interpreter.
Category:LanguagesCategory:2016Category:Stack-basedCategory:Turing completeCategory:ImplementedCategory:Low-levelCategory:Output onlyCategory:Esoteric subset
MiniBitMove

MiniBitMove is an language with only two-commands. It takes two inputs, the code and the data tape. Both consist of ones and zeros.
==Commands==
Each character is one command.
Command	Effect
1 	Flip the bit at the current cell
0 	Move the tape head to the next cell
The program only stops when the tape head reaches the end of the data tape, looping continuously until it does so. This means that if a program has no zeros, it is an infinite loop.
==Examples==
Flips all the bits in the tape:
 Code: 10
 Data: 11111
 Result: 00000
Infinite loop:
 Code: 1
 Data: 111
 Result: Program never ends
==Computational class==
MiniBitMove can't be a linear bounded automaton because it wouldn't be Turing-complete if it had an infinite tape. One reason is because it can't access values from before once it moves right, which sounds like a finite state machine at first. However, it can't do conditional jumps, which implies that it is less powerful than even a finite state machine.
==External resources==
* An interpreter written in lua
Category:Languages
Category:Cell-based
Category:2017
Category:Implemented
Category:Unusable for programming
MiniBrainflop

miniBrainflop is a more compact dialect of brainflop. Instead of having 7 instructions, it only has 5 and is still Turing-complete. It also has less memory space, with 24 cells instead of the original brainflop's 1024.
== Instructions ==
 + Increment the cell under the pointer
 - Decrement the cell under the pointer
 > Move the pointer right
 * If the current cell is 0, get input. Else, print the cell's ASCII value.
 / If the cell is 0, skip the next instruction. Else, move the pointer left. Relative jump the number under the pointer (negative goes backwards, positive goes forwards).
== External resources ==
An interpreter
Category:Languages Category:2020 Category:Cell-based Category:Turing complete Category:Turing tarpits Category:Low-level Category:Implemented
MiniMAX Turing-completeness proof

The following is a proof that MiniMAX is Turing-complete, via analogy with extended Smallfuck.
Smallfuck becomes Turing-complete if the following command is added:
; & (EXTEND) : Move one cell to the right and zero it. If at the rightmost cell of the tape, instead add a new cell to the right of the current cell and zero it.
(This command is required for Turing-completeness, because Smallfuck has a limited-length tape; note that MiniMAX also has a limited-length tape, so tape extension is something that needs to be compiled into a program explicitly. F2 cannot be used, because the boundedness of the tape.)
The proof is a construction. The MiniMAX program consists of a set of commands that mirror Smallfuck commands, followed by a data area, originally consisting of nothing but the word meaning 1, repeated four times for each data element of the original Smallfuck tape, plus four times extra. The program must start with (implementation-specific) commands to set up the current and previous commands so that the previous command was the first three words of the data area, and the current command is the first command in the code area. Then, Smallfuck commands can be translated mechanically as follows. The code is given in decimal.
('fix' and fixup numbers are explained below the table; 1 and 0 are optimizations that set or clear the current cell, respectively, but are not required for the proof).
Command	Fixupnumber	MiniMAX code
* 	40 	1 -4 1 1 1 -2 1 1 13 -2 1 1 1 -4 1 1 9 -1 1 1 13 -2 1 1 1 -6 1 1 1 -1 1 1 1 -2 1 1 1 -4 1 1
< 	4 	1 -7 1 1
> 	4 	1 1 1 1
[ 	20 	1 -2 1 1 1 -4 1 1 1 -4 1 1 fix -2 1 1 1 -2 1 1
] 	16 	1 -2 1 1 1 -4 1 1 fix -2 1 1 1 -4 1 1
& 	16 	1 -2 1 1 1 -2 1 1 1 -2 1 1 1 -2 1 1
1 	8 	1 -5 1 1 9 -1 1 1
0 	8 	1 -5 1 1 1 -1 1 1
The resulting program needs fixup. The 'fix' in every [ command should be changed to 9 plus the total fixup value of all the commands between that [ and the corresponding ]. The 'fix' in every ] command should be changed to -27 minus the total fixup value of all the commands between that ] and the corresponding [.
If I/O is required, extensions to do this have to be added to both MiniMAX and Smallfuck. If the MiniMAX implementation allows the program to end, the code necessary to do this can be placed just after the code area.
Category: Proofs
MiniUSPL

Still adding instructions. --OberoN 17:40, 6 November 2011 (UTC)
miniUSPL (mini Unic Stack Programming Language) is an esolang. It's also a Turing tarpit.
== Overview and Instructions ==
In miniUSPL you have a FIFO stack of characters, and 14 instructions, as well as 14 symbols.
These are:
 = -> Prints the stack[0] as a char
 $ -> Prints the stack[0] as an int
 + -> stack[0]=(stack[0]+stack[1]) mod 256
 - -> stack[0]=(stack[0]-stack[1]) mod 256
 * -> stack[0]=(stack[0]*stack[1]) mod 256
 / -> stack[0]=(stack[0]/stack[1]) mod 256
 & -> stack[0]=stack[0]&stack[1]
 | -> stack[0]=stack[0]|stack[1]
 ^ -> stack[0]=stack[0]^stack[1]
 > -> Pushes the next char onto the stack
 < -> Pulls and discards the first item
 % -> Duplicates and pushes stack[0] onto the stack
 ( -> While stack[0] isn't equal to the next char, it loops over the 2nd next char
 { -> Start of an infinite loop
 } -> End of an infinite loop
=== Programs ===
This is the Hello World program:
 >H=>e=>l==>o=> =>W=o>=r>=l>=d>=>!=
And this calculates the Fibonacci sequence:
 >�>�-${+%$}
Category:Languages
Minibiatch

Minibiatch is a RISC architecture invented by Ben Russell. It can have any degree of bits, though 16 is most practical.
==Specification==
The specification has been removed as it was not public domain. See license below.
==Examples==
The example has been removed as it is unclear whether the license below includes it, in which case it is not public domain.
==License==
"Minibiatch is made by Ben Russell, 2006. Anyone who wishes to do anything with Minibiatch including redistribution of the specification must include this quote somewhere. That's all I ask."
==See Also==
*User:GreaseMonkey for a specification of Midibiatch, which isn't an esolang.
Minic

Minic is a variation of C that looks a lot like C that is invented by User:A. It maintains the goals of Keg as much as possible. Its primary purpose is used for golfing. However, it will only do good on complex problems, as simple problems(like the Hello, world! program) will result in a long program in Minic.
==Differences==
You should note that the parameters of main is used to declare variables, and you can declare them elsewhere. However, declaring them in the main parameters significantly golfs programs.
Example:
main(x=1,y='2',z[12]="3") {}
This defines x as 1, y as 2, and an array z with length 12 as the string 13.
Of course you don't have to set them into values:
main(x,y,z[12]) {
}
Other than that, the differences are so tiny that they are barely noticable.
==Examples==
===Calculate the Pyramid problem===
Several balls are in a pyramid.
On the first row, there is 1 ball.
On the second row, there are 3 balls.
On the third row, there are 6 balls.
On the fourth row, there are 10 balls.
...
If there are 100 rows, how many balls are there? (It should print 171700) (55 bytes)
main(s,t,i=1){for(;i<101;++i)s+=t+=i;printf("%d\n",s);}
===Hello, world! program (32 bytes)===
main(){puts("Hello, world!");}
===Enumerate how many 'A' 's are on a line of input (64 bytes)===
main(i,c){for(;(c=getchar())!=-1;c==65?++i:0);printf("%d",--i);}
===Make a function w evaluating what weekday is on a specified year, month, and day. (71 bytes)===
w(y,m,d){if(m<3)m+=12,--y;return(d+2*m+3*(m+1)/5+y+y/4-y/100+y/400)%7;}
===Enter a string.===
Enter a string. Change all characters in the alphabet to the next character in the alphabet without changing other characters. The next charater of Z is A, and the next character of z is a. (83 bytes)
main(c){for(;(c=getchar())!=-1;isalpha(c)?++c:0,c==91||c==123?c-=26:0,putchar(c));}
===99 bottles of beer program(164 bytes)===
main(b=99){for(;(printf("%d bottles of beer on the wall, %d bottles of beer.\nTake one down, pass it around, %d bottles of beer on the wall.\n",b,b,b-1),b>1);--b);}
Category:2019
Category:Languages
Category:Golfing language
Category:Unimplemented
Minifuck

Minifuck is a very minimalistic version of Brainfuck, made by User:Wh1teWolf. It has only 3 instructions and uses an right-infinite tape of binary bits as storage. It should be turing-complete.
==Commands==
*<: Same as Brainfuck
*.: Move to next bit and invert it and output letter stored in first 8 bits, if none then input
*[: Move to next bit and invert it, skip next instruction and invert next bit if zero
==Examples==
===Cat===
 <[<.[<.
==Implementations==
A Python interpreter by User:Bangyen.
==See Also==
*Minifuck-2D
*Ultimate bf instruction minimalization!
Category:Languages
Category:Low-level
Category:Brainfuck derivatives
Category:Cell-based
Category:Turing complete
Category:2009
Category:Implemented
Minifuck-2D

Minifuck-2d is a two-dimensional programming language invented by User:Wh1teWolf Dec 2, 2009. It has only four commands and it should be turing-complete. It is inspired by Minimal-2D
==Commands==
Command	Description
< 	Move to previous bit in memory array. (if currently on the first bit do nothing.)
. 	Move to next bit and invert it, output next 8 bits if at least one of them is non-zero, else input.
! 	Move to next bit and invert it, skip next instruction if zero. (Comments and whitespace counts as an instruction.)
@ 	Turn right.
==Examples==
===Infinite loop===
 !<!@@
 @@
===Cat===
 !<!@!<.<.! ! ! @
 @ ! ! ! ! ! @
==See Also==
*Minifuck
Category:Languages
Category:Low-level
Category:Brainfuck derivatives
Category:Cell-based
Category:Two-dimensional languages
Category:Turing complete
Category:2009
Minigolf

minigolf is a tiny stack-based language inspired by Vyxal's corpus. Programs can be quite long compared to modern golfing languages due to its extremely limited set of builtins, but they tend to be shorter compared to practical languages. Besides constants and characters that transpile to minigolf, it currently has 8 commands (actually 12 due to operator overloading):
Command	Overload 	Description
, ... ;	(int / float) 	map ... over [1..int(n)]
 	(list) 	map ... over TOS
: 	(any) 	Duplicate TOS
* 	(int/list, int)	Multiply. (Vectorizes)
 	(list) 	Flatten the list on TOS.
+ 	(int/list, int)	Add. (Vectorizes)
 	(list) 	Sum the TOS. (Vectorizes at depth 1)
i 	 	Push next (cyclic) input (or -1 if input is empty)
n 	 	Push current item in map (or 2 if outside of loop)
s 	(any, any) 	Swap the top two stack items.
= 	(list/int, int)	Equality. (Vectorizes)
 	(list, list) 	Zip two lists together.
Additionally, the following characters transpile to their equivalent minigolf substring:
Character	Replacement
_ 	0;++ (useful for foreach loops)
# 	,1;+ (length of a list)
o 	:#s,ns_,; (reverse a list)
The input for the program is taken from STDIN, split by newlines, and each item is evaluated as Python. Strings are converted to lists of codepints. This produces an input list for the program.
The entire stack is implicitly outputted after the program. If the -c flag is on, then each stack item is implicitly chr'd. If TOS is an array, then the inner lists are flattened, then the inner lists mapped with chr then joined with "", then the outer lists joined with "\n", and finally the resulting list is outputted.
It is important to note that unlike other stack-based langauges such as 05AB1E or Factor, the map builtin does not implicitly push the current iterated item onto the stack. An explicit n is required to do that. (This makes the map builtin a bit more flexible.)
The map loop pops TOS after each iteration, and pushes a list of each popped item after the loop.
Additional constants and flags in minigolf can be found by reading the source code.
== Example programs ==
=== Sort the input list ===
Here is a program I wrote on CGCC that sorts the input list via insertion sort.
0,;i,:#1,;ns,s,n2,;:,n_T*+0s,,_1_,o_,n__n1+,;o__
=== Deadfish interpreter ===
0i,nWT*+1,;,nB=,:_n0=,T+_n5=,1+_nF=,:*__::V=sT=+,0*__,_
=== Primalty checking ===
iT+:,:ns,:n*;s,_;*i=+0=s0=0=*
=== Factorial of the input ===
1i,n*_
== External Resources ==
* GitHub Repository
Category:Languages
Category:2023
Category:Implemented
Category:Stack-based
Category:Golfing language‏‎
Category:Low-level
Minimal

Minimal is an esoteric programming language developed by Alegend on August 10, 2009. User:Madk wrote an interpreter in July of 2010. It only consists of 7 commands.
==Commands==
* < Move the data pointer left.
* > Move the data pointer right.
* + Add to the value in the data pointer.
* - Subtract from the value in the data pointer.
* . Outputs the value in the data pointer.
* , Asks for input from the user.
* / Skips next instruction if the data pointer is set to 0.
The author designed it to be minimal, but Turing-complete. However, it is not, because it lacks useful conditional execution or loops; every program will always halt, each instruction having been executed at most once. 
==External resources==
Download interpreter
Category:Languages
Category:Brainfuck derivatives
Category:Cell-based
Category:Implemented
Category:Unusable for programming
Category:2009
Category:Total
Minimal-2D

Minimal-2D is the name of a 2D programming language made by User:Alegend, on August 10, 2009. It only has 11 commands:
Cmd	Description
< 	Move the data pointer left.
> 	Move the data pointer right.
+ 	Add to the value in the data pointer.
- 	Subtract from the value in the data pointer.
. 	Outputs the value in the data pointer.
, 	Asks for input from the user.
/ 	Skips next instruction if the data pointer is set to 0.
U 	Tells the program to switch to the up direction of processing instructions.
D 	Tells the program to switch to the down direction of processing instructions.
L 	Tells the program to switch to the left direction of processing instructions.
R 	Tells the program to switch to the right direction of processing instructions.
The program, when it starts, automatically starts processing in the rightward direction.
==Example==
===Hello World===
>++ R<+++D R >++++++>+++++++++>++++++++++D
D++>R/ </ +/U/-<<<<<<+++++++++++>+++>++++>L
+ UU/->+LD .++++++++++>.--------.----L
R+++.>++.>--..+++.>.>-.>--.--------.+++.--U
==Computational class==
Minimal-2D is obviously Turing-complete through reduction from Brainfuck, as a Brainfuck loop
<nowiki>abcd[efgh]ijkl</nowiki>
can be translated as:
abcd/D /LRijkl
 Refgh/UU
==External resources==
* An interpreter can be found here.
* An interpreter written in c++ with additional (but optional) language features can be found here.
Category:2009
Category:Brainfuck derivatives
Category:Implemented
Category:Turing complete
Category:Two-dimensional languages
Category:Languages
Minimal CISC

The minimal CISC instruction set presented here is stack-based and composed entirely of zero-address instructions. There are only 8 instructions, so each can be coded as a 3-bit syllable. Assuming a 16 bit word, 5 instruction syllables can be packed in each word (the least significant syllable is the first). 
This writeup is a revision of a paper by the same name published in ACM Computer Architecture News, 16, 3 (June 1988), pages 56-63.
The instructions are:
 NOP: No operation.
 DUP: Duplicate the stack top. This is the only way to allocate stack space.
 ONE: Shift the stack top left one bit, shifting one into the least significant bit.
 ZERO: Shift the stack top left one bit, shifting zero into the least significant bit.
 LOAD: Use the value on the stack top as a memory address; replace it with the contents of the referenced location.
 POP: Store the value from the top of the stack in the memory location referenced by the second word on the stack; pop both.
 SUB: Subtract the top value on the stack from the value below it, pop both and push the result.
 JPOS: If the word below the stack top is positive, jump to the word pointed to by the stack top. In any case, pop both.
Minimal operation language

Minimal operation language is a test esolang by User:PythonshellDebugwindow.
==Syntax==
Each line is a sequence of unsigned integers of arbitrary size separated by operators (other than lines with goto), e.g.:
 1 + 2 - 3 * 4 / 5
Spaces (other than newlines) don't matter. The result of each line is printed to STDOUT with a newline, so the above code would print:
 0
because with Minimal operation language's OOO (see #Operators), and / being floor division:
 (1 + 2) - ((3 * 4) / 5) = 0.6
Any question marks will be replaced with user input with the prompt ? , e.g.:
 ?
is a numeric cat program. Also:
 1?5
with input 7 gives:
 175
or with input 123 gives:
 11235
or with input abc gives:
 105
because abc is not a valid integer in Minimal operation language (regex: [0-9]+, no preceding + allowed)
==Operators==
Operator	Operation 	Precedence
+ 	Addition 	5
- 	Subtraction 	6
* 	Multiplication	3
/ 	Floor division	4
^ 	Exponentiation	2
( 	Grouping 	1
) 	Grouping 	1
== 	Equality 	7
!= 	Inequality 	8
Precedence is 1 for highest, meaning the higher the precedence, the sooner that operation will be solved. The subtraction operator returns the absolute value of its result, the equality operator returns 1 if its LHS and RHS are the same, otherwise 0, and the inequality operator returns 0 if its LHS and RHS are the same, otherwise 1.
==Gotos==
When a line starts with : (colon), the program will jump to the (0-based) Nth line of the program, where N is the number on the line after evaluation (minus the colon). The number on the line will not be printed, and jumping to an out-of-range line will terminate the program without an error. If a line starts with ; (semicolon) instead of :, then the number on the line will be printed before the jump, e.g.:
 1 + 1
 :0
would print out 2 forever, and:
 1 + 1
 ;0
would print out 2 (followed by 0) forever (2\n0\n2\n0...).
===Conditional gotos===
If you prefix a : or ; with a number, then the jump will only happen if that left number is not equal to 0. If a : is used, then no value will be printed out, even if the left number is equal to 0, but if a ; is used, then the right value will be printed out. For example:
 ?:3
 0
 :4
 1
will print out 0 if user input is invalid or equal to 0, and will print out 1 otherwise. This example can be easily modified into a truth-machine.
==Examples==
===Numeric cat===
 ?
===Add two inputs===
 ? + ?
===Truth-machine===
 ?:3
 0
 :5
 1
 :3
== Computational class ==
This language has no sign of memory, so it is a Finite-state automaton.
==Resources==
* An interpreter written in NodeJS by User:PythonshellDebugwindow (unfinished as of now)
* Interpreter written in Node.js by User:Hakerh400
* Interpreter written in Io by User:A 
Category:Languages Category:2020 Category:Implemented Category:Finite state automata