nyuuzyou/wikis huggingface dataset:
Malbolge Reborn

Malbolge Reborn is an attempt to make an esolang that's even harder than Malbolge. It is currently in the prosses of being created.
Malbolge Reborn runs on an array, where each cell in the array can hold a different number of values, starting with the first one, at two values. At the start of a program, every cell except for the first one is "locked" which means they can't be accessed. There is a data pointer that starts off pointing at the first (and only) cell in the array. To "unlock" a cell, you have to unlock all cells before it in numerical order. To unlock a cell, you use the unlock command which is represented by the character "#". After each "#" command, you have to put a number of no-ops, or "Q"s. The number of no-ops is determined by this formula: cell capacity^2 plus 3 times current 0-indexed cell value minus 3. So, to unlock the second cell you would write:
 #Q
Since 2^2 + 3 * 0 - 3 = 1. Another thing to note, is that the data pointer will move forward from its original location forward n steps, where n is the amount of "Q"s after the "#", looping back around if necessary, so if you want to unlock cell ten (having ten possible values that is), you would write this:
 #Q#QQQQQQ#QQQQQQ#QQQQQQQQQQQQQQQQQQQQQ#Q#QQQQQQ#Q#QQQQQQ
Now, the data pointer is at the cell with size 9. To change the data pointer, you use the " " command. It moves the data pointer backwards one cell, and if followed by the original cell's size amount of "Q"s. So, if you want to access the cell with size ten, you would type this:
I think the math is wrong somewhere
 #Q#QQQQQQ#QQQQQQ#QQQQQQQQQQQQQQQQQQQQQ#Q#QQQQQQ#Q#QQQQQQ QQQQQQQQQ QQQQQQQQ QQQQQQQ QQQQQQ QQQQQ QQQQ QQQ QQ Q
===Obfuscation===
Each character in the code is transformed by applying the following function n times, where n = the 4-indexed character index in the code. The function is as follows:
Origonal	 	!	"	#	$	%	&	'	(	)	*	+	,	-	.	/	0	1	2	3	4	5	6	7	8	9	:	;	<	=	>	?	@	A	B	C	D	E	F	G	H	I	J	K	L	M	N	O	P	Q	R	S	T	U	V	W	X	Y	Z	[	\	]	^	_	`	a	b	c	d	e	f	g	h	i	j	k	l	m	n	o	p	q	r	s	t	u	v	w	x	y	z	{	 	}	~
New 	w	g	J	b	/	v	%	L	e	[	c	r	M	d	=	U	C	+	G	m	9	'	n	H	?	K	}	^	2	Z	z	3	P	I	X	0	u	l	 	(	,	R	.	&	x	_	f	t	a	~	!	\	s	Y	S	`	A	y	o	p	V	>	Q	8	1	O	i	:	]	)	W	E	 	;	-	<	T	5	D	N	7	{	j	"	4	@	B	k	#	F	$	6	h	*	q
So the code:
 #Q#QQQQQQ#QQQQQQ#QQQQQQQQQQQQQQQQQQQQQ#Q#QQQQQQ#Q#QQQQQQ QQQQQQQQQ QQQQQQQQ QQQQQQQ QQQQQQ QQQQQ QQQQ QQQ QQ Q
Would become:
 ^n~u@PaOt@9K&%vBKAIR!gElTs"J.=ZoNfW`1+fj`d]>z$/]YzF|h wkJ2G(e)[p7H+M_8?3m5'/x#bi;^Qwq{6nDu)PaOt4MK&%vmXAIx!gil
==External Resources==
Obfuscation Program(The wierd symbol at the end isn't part of the obfustcation, it's just to let you know if there is a space at the end) (You have to change the string in the code.) (You can also deobfuscate)
Category:LanguagesCategory:2024Category:UnimplementedCategory:Cell-basedCategory:Works-in-Progress
Malbrain

Malbrain is an esoteric programming language with only 2 commands: > and .. Due to the design, it is also extremely hard to maintain, since each command is relative to the previous.
Malbrain is translated to brainfuck before it is executed and so is computationally equivalent to brainfuck. This is NOT the same as a turning tarpit.
==Commands==
The commands are:
Token	Action
> 	Next command
. 	Use command
The command number starts at 0 at the beginning, which is >. The output commands, their arrangement, and internections, are as follows:
Number	Current brainfuck command	Next brainfuck command
0 	> 	<
1 	< 	+
2 	+ 	-
3 	- 	.
4 	. 	,
5 	, 	[
6 	[ 	]
7 	] 	>
Like brainfuck, all non commands are considered comments. If the command goes past the list, it restarts to 0.
==Examples==
===Hello World!===
This is the brainfuck hello world converted to malbrain
.>>.........>>>>.>>>.>........>>>>>>.>>>.>>>>.>>.>>>.>>>>.
>>.......>>>>.>>>.>....>>>>>>.>>>.>>>>.>>.>.>>.>>>>>>.......
>>..>>>>>>...>>.>>>>...>>........>>>>.>>>.>....>>>>>>.>>>.>>>>.
>>.>>>.>>>>...>>..........>>>>.>>>.>.........>>>>>>.>>>.>>>>.>>.
>>...>.>>>>>....>>>.>>>>>>...>>.>>>>>>>......>.>>>>>>>........>.
>>>>..>>.>>.
===Cat program===
This is malbrain cat (No change on EOF)
>>>>>.>.>>>>>>.>>.>>>>>.>>>>.>>>>>>.>>.
===Truth-machine===
A truth-machine is operated in this example:
 >>>>>.>>>>>>>.>>.>>>>>..>>>>>.>>.>>>>.>>..>>>>>>>.>>.>>>>>.>>>>>>.>>>.>>..>>>>>>.
==External resources==
*Malbrain Source Code
*Malbrain ELF (libc6)
*Malbrain Win32
*Common Lisp implementation of the Malbrain programming language. The project also comprehends converters betwixt Malbrain and brainfuck in both directions.
==See also==
* ?!
* Twocoman
Category:Brainfuck derivatives
Category:Turing complete
Category:Implemented
Category:Turning tarpits
Category:Languages
Malfunge

Malfunge is an esoteric programming language created by User:ArthroStar11 heavily inspired by Befunge and Malbolge
== Data Structure ==
The data structure of Malfunge is an array of 5 stacks of 32-bit signed integers each with a max size of 1000
== Playfield ==
Much like Befunge, Malfunge uses a playfield of fixed size. In the case of Malfunge the playfield is a 256 x 256 table of characters.
== Command List ==
=== Flow Control ===
Important note: for brevity this section will mention "h-cond" and "v-cond" these represent behaviors identical to Befunge's "_" and "|" respectively
* Retroreflectors (<, >, ^, and <)
** if approaching from the concave side (i.e from the left with ">") will invert the direction of the program (i.e. left for ">")
** if approaching from the sloped sides (i.e from above or below with ">") will send the program in the direction of the point (identical to Befunge)
** if approaching from the pointed side (i.e from the right with ">") will perform a v-cond if retroreflector is pointing horizontally, h-cond otherwise
* Paddles (| and _)
** | will invert the direction if approaching from the left or right, performs an h-cond otherwise
** _ will invert the direction if approaching from above or below, performs a v-cond otherwise
* Mirrors (/ and \)
** will reflect the direction 90 degrees represented visually by the mirror (behaves identically to AsciiDots)
* Misc
** ? changes the direction randomly
** o skips the next command in the direction of the pointer
=== Math ===
* numbers (0 to 9)
** pushes the corresponding number to the current stack
* Operators (P, M, T, D, and m)
** pops a then b off of the current stack then pushes b(op)a onto <(current stack + 1) % 5>
*** P adds
*** M subtracts
*** T multiplies
*** D divides
*** m performs modulo
=== Stack Control ===
* S shifts to the next stack up
* s shifts to the next stack down
=== I/0 ===
 on current stack 
* user input
** , pushes user input as a character
** . pushes user input as an integer
* output
** ; pops value as a character and prints
** : pops value as an integer and prints
=== Misc ===
* " toggles string mode (identical to Befunge)
* I pops a then b off the current stack then pushes 1 if b>a, pushes 0 otherwise
* i pops a off the current stack then pushes 1 if a == 0, pushes 0 otherwise
* d duplicates top value
* @ ends the program
== Sample Programs ==
Hello World
 0"!dlrow olleh"o>d;v
 > <
 @
Truth Machine
 .o>dd:v
 > <
 @
== Implementation ==
ArthroStar11's Interpreter (C source)
Category:Unknown computational class
Category:2021
Category:Languages
Category:Stack-based
Category:Low-level
Category:Implemented
Category:Two-dimensional languages
Malloc

Malloc is a joke esolang created by User:None1. All it can do is allocating memory.
==Syntax==
Malloc has only one command - malloc.
The syntax of the malloc command is:
 malloc x
That will allocate x bytes of memory.
Malloc CAN'T free the memory it allocated. 
==Example Programs==
Allocate one byte of memory:
 malloc 1
Allocate 1KiB of memory:
 malloc 1024
Alternative:
 malloc 512
 malloc 512
Allocate the most memory possible in 1 line (2GiB?):
 malloc 2147483647
(Be careful, running this will leak a lot of memory)
Damage the computer:
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
 malloc 2147483647
Allocates 128 GiB of memory, most computers don't have that much memory. How to fix it? Restart your computer!
==Interpreters==
===C===
#include<stdlib.h>
#include<stdio.h>
int main(){
 int x;
 while(scanf("malloc %d\n", &x)!=EOF){
 malloc(x);
 }
 return 0;
}
Category:Languages
Category:Joke languages
Category:No IO
Category:Unusable for programming
Category:2023
Category:Total
MangularJS

MangularJS (MJS) is a restricted version of NodeJS created by User:PythonshellDebugwindow.
==Restrictions==
* No periods or square brackets are allowed in the source code, even in strings, nor are any escape codes that would produce a period or square bracket.
* The = operator and compound assignment operators are not allowed.
* All numbers are either integers or NaN.
* The alert, eval, and require functions are undefined.
* Division is floor division.
* The exports, module, and process objects are undefined.
* The import and export keywords are not allowed.
* Strings are delimited by colons (:) instead of quotes; colons in strings can't be escaped or replaced by any equivalent escape codes, as these are treated as non-escaped colons.
==Examples==
===Hello, World!===
 with(console) log(:Hello, World!:);
===Stack class===
 function Stack() {
 return {
 stack: Array(),
 push: function(x) {
 with(this) {
 with(stack) {
 push(x);
 }
 }
 }, pop: function() {
 with(this) {
 with(stack) {
 return pop();
 }
 }
 }
 };
 }
==See also==
* HaltJS
* Javagony
Category:2020 Category:Unimplemented Category:Languages Category:Unknown computational class Category:High-level
Manuever

Manuever is a joking esoteric programming language created by User:Orange7Official.
== Commands ==
You can use this commands:
* A: Prints three random alpha release names.
* B: Prints the name of a random animal/bug/reptile/bird starting with the letter B.
* C: Puts instructions of any other random esoteric programming language.
* D: Prints random punctuation.
* E: Prints the code of a Hello World program, 99 bottles of beer program, or a cat program.
* 1: Prints the name of a random company/social network/(esoteric) programming language created last year.
* 2: Prints a random ever number.
* 3: Prints the name of a random company/social network/(esoteric) programming language created 3 years ago.
* 4: Prints a random leap year.
* 5: Prints the name of a random video game/(esoteric) programming language/website founded 5 years ago.
* 6: Prints the birth year of people born 6 years ago. In other words, the birth year of people that are starting school this year in most countries.
* 7: Prints the current Unix timestamp.
* 8: Prints a number divisible by 8.
* 9: Prints the lyrics of 99 bottles of beer.
=== Bonus commands ===
Here, you can find bonus commands.
* H: Prints Hello, World!.
* P: Prints text shown between two parentheses.
* Y: Prints the current year, or a random common year.
* Z: Prints a random program in ZOMBIE.
=== Symbolized commands ===
Here, you can find commands marked with a symbol rather than a letter or a number.
* -: Decreases the counter by 1.
* +: Increases the counter by 1.
* !: Prints an event happening today.
* ?: Prints a random question and its answer. The format uses Q: at the start of a question and A: at the start of the question's answer.
* &: Prints two names/words/colors.
== "Hello, World!" programs ==
Primary:
 P(Hello, World!)
Secondary:
 H
Category:Languages Category:Joke languages Category:2024 Category:Output only Category:Total Category:Unusable for programming
Mao

==Mao==
The only thing that I can tell you about this programming language is that I can't tell you anything else.
==Syntax==
Figure it out.
==Examples==
===Quine===
Classified
===Cat===
Classified
===Hello, world!===
Classified
===99 Bottles===
Classified
===Fibonacci===
Classified
===Factorial===
Classified
===Spambot===
Forbidden
==Interpreter==
Confession: there is no standard for Mao, but the idea is to make your interpreter however you like and have other programmers figure out the programming language. This is based on the card game Mao.
Mapfuck 2: Turing Boogaloo

Mapfuck 2: turing boogaloo is a derivative of the original mapfuck programing language made by User:QTpye (talk) with 2 differences
instead of updating the instruction map base on the last char, it updates the map based on the last char and then updates a second time based on the next char in the program
the next and last char are wrapped around to the first and last char of the program
this causes a major problem. while we can take a piece of code and extract the instructions that it generates
if we try to reverse it. and design a piece of code based on a set of instructions we want it is very difficult at best and impossible at worst
here is an example of the program + being run
step 1: assemble the map
this is the default map, put through the previous char`s change table (it's self due to wraping), and then next char`s change table (it's self due to wraping)
so the instruction table becomes
Work Table (showing both changes)
instruction	default	+	+
1 	1 	1	1
2 	2 	3	5
3 	3 	5	2
4 	4 	7	6
5 	5 	2	3
6 	6 	4	7
7 	7 	6	4
8 	8 	8	8
Instruction Map
instruction	char #
1 	1
2 	5
3 	2
4 	6
5 	3
6 	7
7 	4
8 	8
so the instruction for char 3 is instruction 5.
so the program + Outputs the character signified by the cell at the pointer
Marb

marb is the creators second 2D language based on Lean Mean Bean Machine which it self is inspred by Plinko, created by User:Ractangle
==Syntax==
Symbol	Action
\ 	move pointer right
/ 	move pointer left
[ 	Push the accumulator to stack
+ 	increment the accumulator
- 	decrement the accumulator
[ 	append the accumulator to the stack
_ 	ends the program
^ 	pops the top value on the stack and check if it's not 0. If it is, move pointer right. Else move pointer left
. 	Outputs the top of stack
? 	Appends interger input to stack
n/" " 	NOP
= 	Jumps to the top. If the command is in the y-axis of this command, the marble will jump to 1 line below the
==Examples==
===Infinite loop===
 \/
===Truth-machine===
 +
 \?_
 -^[
 [n.
 .n=
 _
==Implementation==
https://github.com/Thevitebsk/Thewierd/tree/main/marb
Category:Languages Category:2024 Category:Implemented Category:Two-dimensional languages
Marble Machine

Marble Machine is a two dimensional esoteric programming language made by User:masalt.
==Examples==
===Hello, World!===
"o
H\"
, w
" ,
e "
, o
" ,
l "
, r
" ,
l "
, l
" ,
o "
, d
" ,
, "
, !
" ,
 p
, !
\x
===Cat===
o
?
,
p
x
===Truth Machine===
0
\#
 g
0}1o
. \.
! x
===Fibonacci Sequence===
0
.
1
o
.
+
x
===Disan Count===
#
0 o
\g/
!{~
 .
 2
 +
 &
 ~
 &
 ~
 x
===Infinite Loop===
 o
 x
===Factorial===
Works only with whole numbers greater than 1.
\# o
o\2/
~ g
&~{~
*~ ~
& 1
~ -
& &
\~o~
 &~x
 1\~
 g ~
~}x.
x !
==Implementations==
You can find the most recent official implementation here.
Marble run!!

marble run!! is a 2D esolang created by User:AnotherUser05.
==Syntax==
@ is the marble, these have regular physics. Gravity, velocity, yeah, you get it.
*# - Wall.
*+ - Increase the current value by one.
*- - Decrease the current value by one.
*: - Output the current value.
*; - Get an input and set the current value to the input.
*| - If the current value is 0, then go left, else go right.
*> - Force the marble to go right, resetting both velocities.
*< - Force the marble to go left, again, resetting both velocities.
*^ - Set the marble's Y velocity to go up.
** - Reset both marble's velocities.
*0-9 - Set the current value to this number.
*a-z - Add this letter to the end of the current value.
*A-Z - Set the current value to this letter.
*! - Delete this marble.
==Examples==
Wait, actually I can't do this because it's not interpertated yet, because I don't know the physics... uhhhhh
Category:Languages Category:Two-dimensional languages Category:Thematic Category:Concurrent programming
Mario Maker Calculator is not Turing-complete

In the video "We Built A Computer in Mario Maker!", the Game Theorists describe a machine made in Mario Maker that uses logic gates to add two numbers from 0-7 and prints the result as a decimal, with inputs encoded as 3-bit numbers. The Game Theorists claim that this machine is Turing-complete.
Mario Maker Calculator can be compiled into Python as this function,
def mariomakercalculator(a, b):
 print(a % 8 + b % 8)
which can be unshackled as this,
c = 0
def mariomakercalculator(a, b):
 global c
 c += a + b
 print(c)
A Mario Maker Calculator program consists of arbitrarily many mariomakercalculator() commands.
==Computational class==
If A (ignoring extensions such as I/O) cannot be compiled into B, then B is of a computational class equal to or lower than that of A. If A is a Turing-machine, then B must strictly be weaker than A.
===Problem===
If MMC Unshackled is Turing-complete, this Befunge-93 code should be compilable into it.
0>1+:.v
 ^.:+1<
===Solution===
The initial 0 is implicit.
The top line can be compiled into MMC Unshackled as mariomakercalculator(0, 1). This is also true for the bottom line. Now we have the following.
mariomakercalculator(0, 1)
mariomakercalculator(0, 1)
The instruction pointer moved back to the top, and then to the bottom. We can compile this simply by copies our code. Now we have the following.
mariomakercalculator(0, 1)
mariomakercalculator(0, 1)
mariomakercalculator(0, 1)
mariomakercalculator(0, 1)
This also needs to repeat, and what we would have would also need to repeat. Now we have a program with infinitely many commands. Since this algorithm requires infinitely many instructions, this code cannot be compiled into MMC Unshackled.
===Conclusion===
Therefore, Mario Maker Calculator Unshackled, and by extension Mario Maker Calculator, must be a push-down automaton or weaker. The Game Theorists are wrong.
Category:OISC
Category:Proofs
Mario汉LANG

This is just the MarioLANG written by Chinese.
== Command Table ==
 Caption text
This Esolang	Origin
地 	=
墙 	
始 	#
终 	"
右 	)
左 	(
荣 	+
耻 	-
写 	.
说 	:
读 	,
听 	;
前 	>
后 	<
上 	^
停 	!
越 	[
他 	@
== Extra table ==
 Caption text
This Esolang 	Mean
Any full-width characters	Set the memory cell under pointer to their ASCII code minus 0xFEE0.
空 	Set the memory cell under pointer to 0x0020.
␀, ␁, etc. 	Set the memory cell under pointer to their ASCII code minus 0x2400.
疯 	Generate a random integer between 0 and 10^100 and set the memory cell under pointer to it.
癫 	Print a random integer.
狂 	Print a random čɦɐŗǡƈʈəɾ.
奇 	Generate a random integer between 0 and 16^5(a WORD and a BIT).
== Examples ==
=== Hello, world! ===
Ｈ写ｅ写ｌ写ｌ写ｏ写，写空写ｗ写ｏ写ｒ写ｌ写ｄ写！写␊写停
地地地地地地地地地地地地地地地地地地地地地地地地地地地地
Let's start with a look at the whole program.
# Set the memory cell #0 to 72 and output it as a character. Output: H
# Repeat the operation for 14 times(but every ASCII isn't same). Output: Hello, world!
# Stop Mario and let him fall to EOF.
# Program ends.
=== Fibonacci ===
说荣说右荣说　　　　　后
地地地地地左地地地地地终
　　　　前前耻右右右停
　　　　终地地地地地始
　　　　停越左左左荣后
　　　右始地地地地地终
　　　前耻右荣右停
　　　终地地地地始
　　右停越左左荣后
　　右始地地地地终
　　前　　　　　　　　停
　　地地地地地地地地地始
== See also ==
# MarioLANG
== Categories ==
Category:Languages
Category:Cell-based
Category:Turing complete
Category:2024
Category:Two-dimensional languages
Category:CJK
Marker

"Marker" is a very simple markdown-like programming language invented by User:A.
==Syntax==
It uses Consolas. Plain font 11 pre is used if no tag is specified.
===link===
Link to a specific web page.
Usage:
 link target_page.mk:
 This page(this is the description)
Category:Languages
Category:Output only
Category:Unimplemented
Category:Markup Languages
Markont

Markont is an esoteric programming language created by Tanner Swett in 2013 while up late at night.
== Syntax ==
 <program> ::= { "when" "(" symbol (">" | "<") number ")" "{" { <instruction> } "}" }
 <instruction> ::= ( "BUY" | "SELL" ) number symbol ( "MARKET" | "LIMIT" number )
"symbol" is any non-empty sequence of uppercase letters, and "number" is any non-negative integer.
== Semantics ==
An order consists of a position, which is either BUY or SELL; a symbol; the disposition, which is either MARKET or LIMIT; and, if the disposition is LIMIT, a price. The state of a Markont interpreter consists of the order book, which is a multiset of orders, and, for each symbol, the last trade price of that symbol, which is initially zero.
Two orders cross if one of them is a BUY order and the other is a SELL order; the orders have the same symbol; and either one of the orders is a MARKET order, or the price of the BUY order is greater than or equal to the price of the SELL order.
When an instruction is executed, the specified number of copies of the order are placed. When an order A is placed, if it crosses another order B, then both orders A and B are deleted, and the last trade price of the corresponding symbol is set to the price of order B. (If order B is a MARKET order, the program halts.) If order A crosses multiple orders, then B is the one with the highest price (if A is a SELL order) or the one with the lowest price (if A is a BUY order); if any of the orders which A crosses is a MARKET order, the program halts.
A "when" block is active if the last trade price of the specified symbol compares with the given number in the specified manner. Execution proceeds by choosing an arbitrary active "when" block and executing every instruction within it, in order. This is repeated until there are no active "when" blocks.
== Example ==
 when ( A < 3 ) {
 BUY 3 A LIMIT 3
 BUY 1 A LIMIT 4
 BUY 4 A LIMIT 5
 BUY 1 A LIMIT 6
 BUY 5 A LIMIT 7
 SELL 1 A MARKET
 }
 
 when ( A > 6 ) {
 SELL 2 A LIMIT 7
 SELL 7 A LIMIT 6
 SELL 1 A LIMIT 5
 SELL 8 A LIMIT 4
 SELL 2 A LIMIT 3
 BUY 1 A MARKET
 }
In the above program, the first "when" block executes once, then the second "when" block executes once, then execution halts. The resulting last trade price of A is 4, and the order book consists of the following orders: BUY 1 A LIMIT 3, SELL 3 A LIMIT 4, SELL 4 A LIMIT 6.
Category:LanguagesCategory:2013Category:Nondeterministic