nyuuzyou/wikis huggingface dataset:
MCBlocks

MCBlocks is a three dimensional esoteric programming language created by User:Dominicentek. It's code is written as a build in a Minecraft world with each block representing a command that the interpreter follows. The interpreter accepts .nbt files exported by Structure Blocks. The command pointer starts at XYZ 0 0 0 of the structure moving in X+ direction. Because of the Structure Block limit, each program is limited to 48x48x48 grid.
== Blocks ==
Block 	Description
Oak Planks 	Moves the command pointer X+
Spruce Planks 	Moves the command pointer X-
Birch Planks 	Moves the command pointer Y+
Jungle Planks 	Moves the command pointer Y-
Acacia Planks 	Moves the command pointer Z+
Dark Oak Planks 	Moves the command pointer Z-
Dirt 	Pops a value off the stack
Cobblestone 	Reverses the stack
Stone 	Swaps the first 2 values
Deepslate 	Duplicates the top value on the stack
Cobbled Deepslate 	Pushes a number of values currently on the stack (This number not included)
Block of Iron 	Pops two values X and Y, performs a Math operation Y + X and pushes the result
Block of Coal 	Pops two values X and Y, performs a Math operation Y - X and pushes the result
Block of Gold 	Pops two values X and Y, performs a Math operation Y × X and pushes the result
Block of Diamond 	Pops two values X and Y, performs a Math operation Y ÷ X and pushes the result
Block of Netherite 	Pops two values X and Y, performs a Math operation Y % X and pushes the result
White Wool ... Black Wool 	Pushes current wool color on the stack (White = 0, Orange = 1, Magenta = 2, ..., Black = 15)
Sign 	Pushes ASCII characters of the sign on the stack (multiple lines are joined by a space, empty lines are ignored)
Block of Lapis Lazuli 	Asks user for number input
Block of Emerald 	Asks user for string input (ASCII values will then be pushed)
Block of Quartz 	Outputs top value of the stack as a number
Block of Redstone 	Outputs top value of the stack as an ASCII character
Oak Log (Rotated in X axis)	If the top two values match, The command pointer moves X+, otherwise it moves X-
Oak Log (Rotated in Y axis)	If the top two values match, The command pointer moves Y+, otherwise it moves Y-
Oak Log (Rotated in Z axis)	If the top two values match, The command pointer moves Z+, otherwise it moves Z-
Crimson Hyphae 	Pops two values off the stack X and Y. X is used as address and Y is used as value. Value is then put on the corresponding address in the heap memory.
Warped Hyphae 	Pops a value off the stack used as an address. It pushes a value on the stack that is on that address in the heap memory. If there is no value, a 0 is pushed.
Red Concrete 	Ends the program
== Examples ==
Hello_World.png|Hello World
Truth_Machine.png|Truth Machine
Cat_Program.png|Cat Program
== Interpreter ==
Download
== See also ==
* MineFriff
* CraftyFunge
Category:Implemented
Category:Languages
Category:2021
Category:Stack-based
Category:Non-textual
Category:Multi-dimensional languages
MDPN

MDPN or Multi-Directional Pattern Notation is an esoteric programming language created by Chris Pressey in 1998. It is an extension of EBNF with operators for describing the parsing of multi-directional and multi-dimensional languages.
==External resources==
* 
* MDPN specification at Cat's Eye Technologies
* , which contains a short segment about MDPN
Category:Languages
Category:1998
Category:Unknown computational class
Category:Meta-languages
MESON

MESON is an Esoteric Knowledge Representation Format based on ESON. It's name stands for Minimal ESON, but ESON isn't a real acronym. It is child's play to parse.
==Design goals==
MESON follows the ESON philosophy of being "so easy to parse it melts Nazis' faces and burns out their eyes" and in fact is a strict subset of ESON. It merges ESON's numeric types and prunes the available collections. Like ESON, it is a Turing incomplete language consisting of RPN stack commands.
==Program evaluation==
The program source code is split on spaces. Control flow iterates through each of the words left to right, performing the appropriate stack operations. At the end of the program, the top of the stack is popped and becomes the result of the evaluation. Any other values on the stack are discarded. Consecutive spaces in the source code can be ignored or throw a syntax error, depending on the implementation.
== Commands ==
Command 	Meaning
/[0-9_]+/	Push an integer (_ meaningless, can be used to separate digit groups)
/"[^\s]*/	Push a string delimited by the " and a space. Spaces encoded with %20, newlines with %0A, tabs with %09, vertical tabs with %0B and percent signs with %25.
/\(,*\)/ 	Create a tuple with length(commas)+1 items by popping those items from the stack.
[] 	POP an integer n, POP n items, PUSH the list composed of those items in the order they were popped.
{} 	POP an integer n, POP n items, PUSH the set of those items
Category: Languages
== External Links ==
* Haskell Implementation
Category:Declarative paradigm
Category:Stack-based
MGIFOS

MGIFOS, or My God It's Full Of Stars, is an esoteric programming language created by User:Marz. While 1L consists of 2 characters (+ and space), MGIFOS consists solely of the character *. Its command set is based on Brainfuck.
==Language overview==
MGIFOS is displayed by a series of stars (asterisks). The program is defined by the number of asterisks in the code.
Command (binary)	Description
0001 	Move the pointer to the right
0010 	Move the pointer to the left
0011 	Increment the memory cell under the pointer
0100 	Decrement the memory cell under the pointer
0101 	Output the character signified by the cell at the pointer
0110 	Input a character and store it in the cell at the pointer
0111 	Jump past the matching 1000 if the cell under the pointer is 0
1000 	Jump back to the matching 0111
The commands are concatenated in the order required. For example, to move the pointer to the right and then to the left, the binary would be:
 00010010
This in decimal is 18, meaning that the MGIFOS code is 18 stars in a row:
 ******************
==Examples==
===Cat===
The cat program ,[.,] consists of 423272 stars in MGIFOS. 
===Infinite loop===
The program +[] consists of exactly 888 stars. Oh lol.
===Hello, world!===
The program which prints out the words "Hello World!" consists of (approximately?) 4.5287549098E+168 stars.
It has been noted that there are more stars in the Hello World program than there are particles in the observable universe - but this is just a minor setback.
==See also==
* Ellipsis
* Unary
==Interpreter==
* Common Lisp implementation of the MGIFOS programming language.
Category:Languages
Category:Joke languages
Category:Unusable for programming
Category:Turing complete
Category:Brainfuck equivalents
Category:2007
MIBBLLII

MIBBLLII Isn't brainfuck But Looks Like It Is is a programming language made by Nathan van Doorn. It is based on the wikipedia:B,C,K,W system. It maps input (expressed as a church list of church booleans corresponding to the bits of the input, ending with an infinite stream of church trues) to output (expressed as a similar list, presumably finite).
==Combinators==
Expression	Evaluates as
+ a b c 	a [ b c ]
- a b c 	a c b
. a b 	a
, a b 	a b b
> a 	a
< a b c	a c [ b c ]
[ and ] are used to group combinators for evaluation order.
==Proof of Turing Completeness==
SKI combinator calculus is Turing-complete, and all the operators in SKI exist in MIBBLLII as <, ., and >. It is still Turing-complete without < or >, as the following shows.
 < +[+,][++-]
 > ,.
==See also==
* I hate your bf-derivative really I do
* Combinatory logic
Category:LanguagesCategory:Functional paradigmCategory:2011Category:Unimplemented
MISATOeso

MISATOeso is a joke language based on HQ9+ and the Neon Genesis Evangelion character Misato Katsuragi made by User:Marina. It currently has 6 instructions:
* M: Prints the Misato fantasy copypasta.
* A: Prints the accumulator.
* +/-: Increments/decreases the accumulator with a 29% chance of overwriting the accumulator with a number in the 32-bit unsigned integer range.
* 9: Prints the lyrics to 99 Bottles of Beer.
* B: Prints a brainfuck program that prints "misato".
The language references the Neon Genesis Evangelion character many times, such as using her age as the percentage for the accumulator overwrite and printing jokes about her.
Category:Joke languages
Category:Unusable for programming
Category:Languages
Category:Output only
Category:Implemented
Category:High-level
Category:Total
Category:2023
MISC-x86

N.B: MISC-x86 is not based on MISC by Safalra / Stephen Morley. Nor is it related to Y86 (formerly known as x86).
MISC-x86 is the "Minimal x86 Instruction Subset Computer". Its instruction set is a subset of the 32-bit x86 instruction set, consisting of only 3 basic single-operand instructions (LOAD byte from address X, STORE byte at address X, relative JUMP with address offset X). X is 4 bytes wide. The corresponding x86-32 opcodes are A0, A2 and E9.
This minimal x86 instruction subset is actually able to compute anything a "real" 32-bit microprocessor can (although slower since it operates on the the level of individual bytes). By using LUTs in memory, combined with self-modifying code (which is allowed by x86) to manipulate individual bytes in the 4-byte address operands of the instructions, it is possible to simulate arithmetic, conditional jumps, indirect addressing etc; see the example in ByteByteJump. MISC-x86 can be thought of as the 3-operand ByteByteJump instruction, split up into 3 separate 1-operand x86 instructions. The main difference is that the MISC-x86 jump operand is a relative address offset, while ByteByteJump uses an absolute jump address.
Each of the 3 MISC-x86 instructions have the same basic 5-byte machine code form:
 xx,dd,cc,bb,aa
xx is the 1-byte opcode.
aabbccdd is a 4-byte (relative or absolute) address operand, stored in little-endian byte order (read "backwards").
 Machine code | Mnemonics (FASM) | Description
 ---------------+--------------------+-----------------------------------------------------
 A0,dd,cc,bb,aa | mov AL,[$aabbccdd] | Move 1 byte from memory location $aabbccdd to Acc.
 A2,dd,cc,bb,aa | mov [$aabbccdd],AL | Move 1 byte from Acc to memory location $aabbccdd.
 E9,dd,cc,bb,aa | jmp $aabbccdd | Perform relative jump with address offset $aabbccdd.
==See Also==
* ByteByteJump
Category: Ideas
Category: Low-level 
Category: Languages
Category: Self-modifying
Category: Turing complete
MITLML

MITML stands for More Interesting Thue-like Meta-language. It was created to define languages at ease, sort of like BNF, only for the 21st century user.
It builds on the idea of BNF, but uses some peculiar commands like ¬, ~, |, !. If someone implements MITML, I will either give them 67 chocolate bars or cry.
====Example====
~ = ¬ '.' ^ str ` ( $ ^ str
That was a simple MITML definition which is, in simple MITML (SMIMTL), this:
If input is a dot followed by element of type str, output element str.
Simple!
~ = ¬ '~' ` ( $ ~
====Definition====
~ is input. You can have multiple inputs. 
For example:
~ = ~(2) ` ( $ ~(2)
^ is element. Let's call our input a. We will do the python a.split(" "). If you don't python, it means we just get a, cut it into pieces which are before and a space. Or it can be defined as a bit of something. Lets expand our ~ example:
~ = ¬ '~' int ` ( $ ~(int)
` means 'followed by'.
type(" ") is the data type your definition uses. 
~ = ¬ '~' ` (type("stack").push)
Category:Meta-languages]
MIX

MIX is an esoteric language invented by User:Feuermonster in April 2008.
MIX has one integer (called buffer) to store data.
I couldn't write a hello world program till now. But it should be possible.
=== Instructions ===
*0 Prints out the buffer as a character
*1 Adds 1 to the buffer
*2 Subtracts 1 from the buffer
*3 Adds 60 to the buffer
*4 Sets the buffer to zero
*5 Buffer %= 256
*6 Adds the buffer to the counter
*7 Subtracts the buffer from the counter
*8 Adds the buffer to the index
*9 Subtracts the buffer from the index
=== What's MIX ===
MIX mixes the array, actually it just shifts.
=== Interpreter ===
def main():
	op = ['9','9','9','9']
	code_ = raw_input("Code: ")
	index = 3
	i=0
	code=[]
	buffer=65
	output=''
	to_ip = 0
	for chr_ in code_:
		code.append(int(chr_))
	while (i < len(code)):
		op[0] = code[i % len(code)]
		op[1] = code[(i+op[0]) % len(code)]
		op[2] = int(int(op[1])+int(op[2])) % 10
		op[3] = int(int(op[1])*int(op[2])) % 10
		if(to_ip==):
			i+=1
			continue
		to_ip = op[i % 4];
		to_ip = int(to_ip)
		if(to_ip==0):
			output += str(chr(buffer))
		if(to_ip==1):
			buffer+=1
		if(to_ip==2):
			buffer-=1
		if(to_ip==3):
			buffer+=60
		if(to_ip==4):
			buffer=0
		if(to_ip==5):
			buffer = buffer % 256
		if(to_ip==6):
			i += buffer
		if(to_ip==7):
			i -= buffer
		if(to_ip==8):
			index += buffer
		if(to_ip==9):
			index -= buffer
		temp = op[0]
		#print op
		#print to_ip
		index+=1
		i+=1
	print output
main()
raw_input()
Category:Implemented 
Category:Languages
Category:2008
MKBL-LN

MKBL-LN is a language created by Sgeo. It stands for MetaKit Based Language - Lowlevel Numerical.
It was thus named because Sgeo is planning on other MKBL languages that will be better than this one. This language is a work-in-progress.
Note that this documentation will be worked on..
Time is incremented each step at the end.
Textual representation of a program that prints !:
 order[0,"main","outgoing"]
 outgoing[0,"main",33,"stdout"]
 time[time:I,branch:S,subtime:I]
Keeps track of the time. Should not be specified in the initial program, but needs to exist
Only one row at a time is permitted to exist.
If there are no rows in the table, it is implied that it is:
 time[0,"main",0]
The subtime is probably best explained by example:
#time is currently: time[0,"main",0]
#<order table is loaded and processed, let's assume that it is order[0,"main","reqin,outgoing"]
#time is currently: time[0,"main",1] #Replaces the original row
#<reqin is processed>
#time is currently: time[0,"main",2]
#<outgoing is processed>
#time is currently: time[1,"main",0]
 nextime[time:I,branch:S,nextime:I,nextbranch:S]
Specifies at (time,branch) where to go next. This is how all ifs etc. must be done
 memory[yaddr:I,xaddr:I,value:I]
Memory is 2 dimensional, allowing for things like arrays
yaddr represents the row of memory, and xaddr represents the position in that row
yaddr can be any integer -1 or higher
yaddr -1 is a special read-only row intended for keeping track of time
In this documentation, a special notation will be used:
 MEM[2][1,2,3,4,5]
actually means:
 memory[2,0,1]
 memory[2,1,2]
 memory[2,2,3]
 memory[2,3,4]
 memory[2,4,5]
 
 
 incoming[time:I,branch:S,id:I,value:I,source:S]
time is at what step the value was received, source indicates what table caused it to come (e.g. 'reqin')
id is there in case multiple things come in at the same time and branch.
 outgoing[time:I,branch:S,value:I,dest:S]
time is at what step the line is to be processed, value is what will be output, and dest is where it's going. 
 reqin[time:I,branch:S,type:S,source:S]
Will request input to occur at specified time. and source details where it should come from, e.g, stdin, "~/somefile" for *NIX, or "C:\Somefile".
 tomem[time:I,branch:S,addr:I,table:S,field:S,fieldpos:S]
If the field is a string, fieldpos specified where in the string it happens. If a nullbit is moved to a fieldpos, the rest of the field is cleared.
 frommem[time:I,branch:S,addr:I,table:S,field:S,fieldpos:S]
 order[time:I,branch:S,tables:S]
specifies the order that the tables are evaluated in. memory, incoming, and order are never evauated. If an order isn't given for a time and branch, the last one given is used
Example:
 order[0,"main","reqin,frommem,tomem,outgoing"]
MLang (Mihai Popa)

:
mLang is a language made by Mihai Popa. It's simple, but it supports only math and printing! It has no input!!
== Commands/Instructions ==
 Command List
Command (Instruction)	Meaning 	Equivalence (in Batch)
add 	Adds 2 numbers 	set /a z=%x%+%y%
sub 	Subtracts 2 numbers 	set /a z=%x%-%y%
mul 	Multiplies 2 numbers 	set /a z=%x%*%y%
div 	Divides 2 numbers 	set /a z=%x%/%y%
mod 	Does a modulo from 2 numbers	set /a z=%x%%%%y%
print 	Prints a text string 	echo "text"
== Interpreter ==
=== Batch ===
@echo off
REM Defition for the "print" instruction.
if /i %1 EQU print goto echo
REM Defition for the "add" instruction.
if /i %1 EQU add goto add
REM Defition for the "sub" instruction.
if /i %1 EQU sub goto sub
REM Defition for the "mul" instruction.
if /i %1 EQU mul goto mul
REM Defition for the "div" instruction.
if /i %1 EQU div goto div
REM Defition for the "mod" instruction.
if /i %1 EQU mod goto mod
goto error
REM Code for the "print" instruction.
:echo
cls
echo mLang Code: %1 %2
echo Batch Code: echo %2
echo Output: %2
pause >nul
exit
REM Code for the "add" instruction.
:add
cls
echo mLang Code: %1 %2 %3
echo Batch Code:
echo.
echo set /a result=%2+%3
echo echo %%result%%
set /a result=%2+%3
echo.
echo Output:
echo %result%
pause >nul
exit
REM Code for the "sub" instruction.
:sub
cls
echo mLang Code: %1 %2 %3
echo Batch Code:
echo.
echo set /a result=%2-%3
echo echo %%result%%
set /a result=%2-%3
echo.
echo Output:
echo %result%
pause >nul
REM Code for the "mul" instruction.
:mul
cls
echo mLang Code: %1 %2 %3
echo Batch Code:
echo.
echo set /a result=%2*%3
echo echo %%result%%
set /a result=%2*%3
echo.
echo Output:
echo %result%
pause >nul
exit
REM Code for the "div" instruction.
:div
cls
echo mLang Code: %1 %2 %3
echo Batch Code:
echo.
echo set /a result=%2/%3
echo echo %%result%%
set /a result=%2/%3
echo.
echo Output:
echo %result%
pause >nul
exit
REM Code for the "mod" instruction.
:mod
cls
echo mLang Code: %1 %2 %3
echo Batch Code:
echo.
echo set /a result=%2%%%%%%3
echo echo %%result%%
set /a result=%2%%%3
echo.
echo Output:
echo %result%
pause >nul
exit
:error
cls
echo Syntax error!
pause >nul
To run, call the code as a argument, like so:
mlang.bat print "Hello, world!"
== Examples ==
=== Hello, world! ===
print "Hello, world!"
=== XKCD Random Number ===
print 4
=== A+B Problem ===
add x y
Replace "x" and "y" by the numbers you want. For example:
add 7 4
==See also==
* CreativeScript
Category:Languages
Category:Output only
Category:Implemented
Category:High-level
Category:2024
Category:Total
Category:Unusable for programming
MM1char

MM1char is description of 2-register Minsky machine with instructions: INC, DEC, JZ. It's goal is same as for StackBit: to be easily implementable.
==Syntax==
 + - increment register 1
 - - decrement register 1
 * - increment register 2
 / - decrement register 2
 [abc] - declare label abc
 (abc) - goto label abc
 ~ - if register 1 is zero skip next command
 ` - if register 2 is zero skip next command
==Examples==
===Countdown===
This program sets the value of the register 1 to five, ere it decrements it to zero.
 +++++
 [decrement_register]
 -
 ~
 (decrement_register)
===Register value transfer===
This program sets the value of the register 1 to ten and moves the content to register 2, resetting register 1 to zero in the process:
 ++++++++++
 [transfer_register_values]
 -
 *
 ~
 (transfer_register_values)
==Interpreter==
* Common Lisp implementation of the MM1char programming language.
Category:Languages Category:Turing complete Category:Turing tarpits Category:Implemented
MME!

:Do not implement it! It is only work-in-progress! If you want to implemtent it mark it as version 0.2!
MME!(Memory-Map everything!) is an esolang by User:ChuckEsoteric08.
==Command==
 a b
Copy value a to variable b. Dereference can be made using [ and ]. [a] is value inside variable a. [ [a] ](without spaces) is value pointed by value inside variable a and ect
==Memory-mapped commands==
 a ADD(B) - set B to sum of B and a
 a DEC(B) - set B to subtraction of B and a
 a LABEL - Declare label a
 a GOTO(B,C) - goto if value of B is C
 a IN - input byte and store it's ASCII value in a
 a OUT - output a as ASCII character
 [a] a - stop program
Otherwise it will be Copy operation
==Changelog==
0.1 - first version of the language. Memory Mapped Commands are ADD, DEC, LABEL, GOTO and Condtitional GOTO. Command is copy value to variable
0.2 - second version. Added IO Memory-mapped Commands and unconditional GOTO deleted
MMP

MMP - MicroMathProcessor
This language is built to do math. I suppose that a 'MMP+' could include text output, but currently all I/O is integer I/O because I want all programs to run the same on all platforms; different charsets, and standards would make that impossible.
By default, position 1 is selected on tape. Positions below 1 aren't assumed to exist.
R=register
s	select position R on tape
r	copy tape selection to register
t	copy register to tape
o	output register
i	input to register
(	while register
)	wend
f	if R>0 goto instruction # at tape
g	GOTO instruction R
e	end execution
+	increment register
-	decrement register
<	move selection on tape left
>	move selection on tape right
This language is Turing-complete.
Brainfuck	MMP		Brainfuck	MMP
< 	< 		> 	>
+ 	r+t		- 	r-t
, 	i 		. 	o
[ 	r( 		] 	r)
this conversion shows MMP to be turing complete.
---------------------------------------------------------
Please don't flame me for how bad this language is, or how badly formatted this page is; I am 13 and this is my first esolang.
Not to mention, I can't figure out how to use formatting on this page editor.
Category:Languages Category:2017 Category:Turing complete Category:Cell-based
MOISC

The MOISC, or Many One Instruction Set Computer language, is an esoteric assembly language that is basically the product of taking multiple OISC languages and rolling them into a single language, thus defeating the purpose of a OISC. Since this would otherwise cause a problem with which instruction is used (OISC languages don't traditionally make you specify the instruction as there's only one choice by nature), the instruction _does_ need to be specified in MOISC.
== Instructions ==
The instructions in MOISC are:
* Subtract and branch if less than or equal to zero (SBLEQZ)
* Subtract and branch if negative (SBN)
* Reverse subtract and skip if borrow (RSSB)
* Move (used as part of a transport triggered architecture) (MOV)
* Subtract and branch if non zero ( SBNZ a,b,c,destination)
The names are pretty much self-explanatory.
More may be added as more are known.
MPEL

MPEL (Music Producing EsoLang) is an esolang that produces music.
==Commands==
Basically just branflakes with notes attached and a steady beat.
The tempo's second/first digit is the last digit of the amount of commands.
* 110
* 120
* 130
* 140
* 150
* 60
* 70
* 80
* 90
* 100
Here is the notes that commands make:
 < makes A
 > makes B
 + makes C
 - makes D
 . makes E
 , makes F
 [ makes G
 ] makes chrome music lab's lower G thing
==Hello World==
Here.
Category:LanguagesCategory:Non-textual
MSFE

MSFE # is an extension of MiniStringFuck. It is stack based. I have extended + and in MSFE #. However, this function is completely different. We execute instructions based on the number of +. Here I will list instructions.
Number of +	the corresponding instruction
1 	Top of Stack and the temporary variable increase 1.
2 	Top of Stack and the temporary variable decrease 1.
3 	Top of stack and the temporary variable reduce by a factor of 3.
4 	push the temporary variable to the stack.
5 	pop the top element out from stack
6 	push the input to the stack
7 	pop from the stack as the output
8 	start code block defining.
9 	end code block defining. then push the code block id to the stack.
10 	push the result of if the top two elements are equal to the stack
11 	push the result of if the first element is less than the second element to the stack
12 	run the code block with the second element id if the first element is true
==Interpreter==
...
that's the all.
Category:Languages Category:Implemented Category:Stack-based Category:2024