nyuuzyou/wikis huggingface dataset:
Motherf

Motherf is a programming language inspired by Brainfuck. It compiles any BF program and extends its syntax with a variety of 1 character commands.
== Usage ==
npx @pvoronin/motherf -h
echo "#0#0#0" > code.motherf
npx @pvoronin/motherf code.motherf -i 123
Learning by code (tests folder) is highly recommended.
== Commands ==
* ,: Enter 1 character
* #: Enter 1 number (like , but - 48)
* ": Inline string input
* ': Inline digits input
* .: Output current memory cell (ASCII)
* a: Output one lowercase character (like . but -97)
* A: Output an uppercase character (like . but -65)
* 0: Output the current memory cell as a number (like . but -48)
* +: Increment current memory cell
* -: Decrement the current cell
* <: Move memory pointer to the left
* >: Move memory pointer to the right
* ;: Comment from here to the end of the string
* [: Start a loop
* ]: End a loop
* \: Reverse direction of current cell (+ means - and vice versa)
* /: Direct direction of the memory pointer (by default)
* |: Toggle the direction of the memory pointer
* @: Jump some steps right or left using memory cell value as offset
* =: Lock current memory cell maximum value
* ~: Unlock current memory cell maximum value
* &: Link cell with next one to overflow into
* %: Toggles current cell to be a part of stack
* ^: Push (copy) cell value to stack (tail of stack lost)
* v: Pop from stack (tail of stack gets 0)
* (): Launch code inside brackets over isolated stack - linked list of cells
* $: Eval
* `: Direct output from code
* {: Open numbered portal
* }: Link portal to new cell (or collapse)
* _: Jump to numbered portal
* Skip every empty symbol: space, new line, tab
== Examples ==
The code is covered by tests with extensive comments. Each command has a usage example and description.
== Roadmap ==
The language design is now in beta. Everything may change. I'm considering doing the following:
* Testing <- You can help me here
* Refactoring
* Architecture
* Rewrite into Rust
* Compile to WASM
Please, try this language for 15 minutes and give me your feedback :raised_hands:
== Contributing ==
I welcome contributions to the Motherf project!
If you are interested in contributing, you are welcome in discussions, issues, personal messages, wherever.
Any help will be appreciated.
== External resources ==
https://github.com/pavel-voronin/motherf - Source code
Category:Languages Category:Implemented Category:Cell-based Category:Stack-based Category:Brainfuck derivatives Category:Turing complete
Mountain

:Not be confused with the earlier version of the language.
Mountain is a stack-based esolang created by User:ChuckEsoteric08 which was inspired by Grass and Unreadable. Program is made out of two characters: ʌ and ʍ.
==Commands==
Instructions are 1-indexed and are normally written without spaces between them
Pseudocode	Instruction	Meaning
psh 	ʌʍ...ʍ 	push the number of ʌ (which shouldn't be zero) between ʍ's to the stack
neg 	ʌʍʍ 	negate top element
jmp 	ʌʌʍ 	pop n, a and b and if a is equal to b jump to the n-th instruction. If n is negative or 0 halt
add 	ʌʌʍʍ 	pop a and b  push b+a
rot 	ʌʍʍʍ 	pop number from the bottom and push it to the top
dup 	ʌʌʌʍ 	duplicate top element
out 	ʌʌʍʍʍ 	pop number and output it as ASCII character
inp 	ʌʍʍʍʍ 	push next byte of input to the stack
==Computational class==
Mountain is Turing-complete because it can simulate Minsky machine.
==Examples==
===Cat Program===
The following program demonstrates an infinitely repeating cat program:
 ʌʍʍʍʍʌʌʍʍʍʌʍʌʍʌʍʌʍʌʍʌʍʌʌʍ
===Truth-Machine===
A truth-machine is implemented below:
 ʌʍʍʍʍʌʌʌʍʌʌʍʍʍʌʌʌʍʌʍʌʌʌʌʌʌʌʌʌʌʌʌʌʌʌʌʌʌʌʌʌʌʌʌʌʌʌʌʌʌʌʌʌʌʌʌʌʌʌʌʌʌʌʌʌʌʌʌʌʍʌʍʌʌʍʌʌʍ
==Interpreter==
* Common Lisp implementation of the Mountain programming language. Please note that the concrete character set deployed constitutes a dependency on the Common Lisp implementation; in corollary, Unicode support may or may not be a feature incorporated in the personal environment. The interpreter at hand has been developed and tested with Steel Bank Common Lisp (SBCL) version 1.1.4 as part of the Lisp Cabinet 0.3.5 bundle.
Category:Languages Category:Turing complete Category:Implemented Category:Turing tarpits Category:Stack-based Category:2023
Mountain/Old

Mountain is language by User:ChuckEsoteric08. It has only 4 commands. It goal was to make program look like mountains. The program halts only if current bit is zero
==Commands==
Command 	Meaning
A 	move pointer to the right and flip bit
M 	move pointer to the left
WV[instructions]V 	not do [instructions] if current bit is zero.
I(capital i, not lowercase L)	output next 8 bits as number
==Examples==
===Output ascii code for lowercase h===
 AMA // 0
 A // 1
 AMA // 0
 AMA // 0
 A // 1
 AMA // 0
 AMA // 0
 AMA // 0
 MMMMMMMMI // back to first bit and output
Without comments:
 AMAAAMAAMAAAMAAMAAMAMMMMMMMMI
==Computational class==
Maybe Turing complete
Category:Languages Category:Unknown computational class Category:Cell-based Category:Output only
Mouse

Mouse is a Forth-like stack-based programming language eerily similar to FALSE. It uses Reverse Polish Notation for its mathematical operations, and provides the ability to define single character macros A-Z. In addition to the stack, there are 26 available variables, also designated A-Z. 
==History==
Mouse was created as MUSYS by Peter Grogono in 1969 to help automate the composition and performance of electronic music. The language was updated and renamed Mouse in 1979 for an article in Byte Magazine. In 1983, Petrocelli published a book about Mouse.
==Examples==
 "Hello world."
 $$
===Truth-machine===
Mouse79 dialect:
 ?[1]A=(A.A.![)]
 $$
==References==
* Grogono, Peter "Mouse: A Language for Microcomputers", Byte (July 1979): 198-220
* Grogono, Peter Mouse: A Language for Microcomputers. New York: Petrocelli Books, 1983
==External resources==
* 1979 version of the language described in BYTE magazine, July 1979, vol. 4, number 7.
* wikipedia:Mouse_(programming_language) has a full description of the 1983 version of the language
* 
* David G Simpson has published interpreters for three dialects of Mouse
* Peter Grogono's home page
* Retro Programming has a review of the book, Mouse: A Language for Microcomputers
Category: Languages
Category: Stack-based
Category: Implemented
Category:Turing complete
Category: Before 1993
Mov

Mov is an x86 assembly instruction identified to be Turing-complete by Stephen Dolan in mov is Turing-complete [1] and developed further by xoreaxeaxeax in Movfuscator [2]. It may also be considered the basis of a one instruction set computer archtecture which (unlike Subleq) does not have to use self modifying code.
== About the Mov instruction ==
The mov instruction has a number of different forms. Let r1,r2 denote registers, then for example:
* mov r1, 42 % store the number 42 in r1
* mov r1, r2 % fetch the value in r2 and store it in r1
* mov [r1], 42 % store the number 42 in the address the register r1 points to
* mov r1, [r2] % fetch the value the address in register r2 points to and store it in r1
* mov [r1], r2 % store the value register r2 in the address the register r1 points to
The expressions in brackets can also include +offsets or even adding two register together. All of these features are made use of in different encodings.
== Equality Test ==
To test equality of 'x' and 'y':
 mov [x], 0
 mov [y], 1
 mov result, [x]
This works by having a large array which is written into and read back out from. If x = y the readback will give 1 and it would be 0 otherwise.
== Arithmetic and Logic ==
Arithmetic and logic gates can be encoded using lookup tables. For example to find the xor of x and y we have the following lookup tables
 xor_xy: dd xor_0y, xor_1y
 xor_0y: dd 0, 1
 xor_1y: dd 1, 0
and the code is
 mov r1,[xor_xy+x]
 mov r2,[y]
 mov result,[r1+r2]
== As a compilation target ==
The movfuscator repo contains an example compiler from brainfuck to mov instructions. The author also wrote an lcc (C compiler) backend for it. The result is extremely long linear code with no branches which can cause reverse engineering tools to crash.
== References ==
* [1] 
* [2] movfuscator
Category:Esoteric subset
Category:Computational models
Category:Turing complete
Category:Before 1993
Category:Implemented
Category:OISC
Category:Languages
MoveDelete

MoveDelete is a stack based programming langauge with two stacks.
If a letter is capital, the stack used is stack1
If a letter is lowercase, the stack used is stack2
both stacks start with a value of 1
 Syntax
Command	Description
I/i 	take input as a ascii character
O/o 	output top value of stack as a ascii character
A/a 	add the top two values of the stack together and push the result
N/n 	replace the top value of the stack with it's negated version
C/c 	push the top value of the stack, cloning it.
M/m 	replace the second to top value of the unused stack with the top value of the used stack removing it from the stack in the process (or top value if the unused stack only has one value)
* 	delete values from stack2 until it hits a 1 (still deletes the 1), then push 1 if the entire stack was deleted
!n 	jump to command n if the top value of both stacks are equal
>n 	jump to command n unconditionally
# 	output the entirety of both stacks
Code stuff:
Cat program:
 IO>1
Truth Machine:
 CAAAACACAANIAcna!28nmnMMNMao>19MMNO
MoveIt

MoveIt is an esoteric programming language made by User:AmNow, MoveIt moves bytes around, hence the name.
== Commands ==
 Command Move Byte: To
 → First End of program
 ← Last Start of Program
 ▶️ Before CMD Start of program
 ◀️ After CMD End of program. 
 ⏪ First Before CMD. 
 ⏩ Last After CMD.
 ⏭ First After CMD.
 ⏮ Last Before CMD.
 » Before CMD After CMD
 « After CMD Before CMD
 🔶: If the byte before and byte after this command aren’t equal, delete them. 
 🔷: If the byte before and byte after this command are equal, delete them.
All other characters will print themself out.
 
() can be used to group things together into a single block.
 (hi)»
The program when it hits the »:
 »(hi)
The instruction pointer will stay on the command it is on after an operation.
Note that 1 is equal to (1).
== Programs ==
=== Infinite Loop ===
 →→
=== Hello, World! ===
 Hello, World!
=== Quine ===
 A
=== Spam #s ===
 #→→
Category:Languages
Movesum

Movesum is an esolang by User:PythonshellDebugwindow where the only instructions are move and sum.
==Memory==
Movesum programs have access to a right-unbounded array of unbounded unsigned integers referred to in this article as the array. Access to the array is 0-based.
==Syntax and Semantics==
===First line===
The first line of a Movesum program is a series of space-separated Key=Value pairs. There can be as many or as few of these pairs as you like. They represent the initial values of the array, the Keys being indexes and the Values being values. Keys and Values are normally numbers, but if either one is 42, it will be replaced with a user input number (0 on EOF). So this:
 0=4 3=8 19=3 15=12345
would set the array to
 4, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 12345, 0, 0, 0, 3, 0, 0, 0, ...
where ... is an infinite amount of zeros. This line can't be empty, but something like 0=0 is fine.
===Rest of the program===
The rest of a Movesum program is a series of instructions, one per line. These instructions are move and sum. To execute an instruction, type its name followed by any arguments it might take (two arguments for move, no arguments for sum). The move instruction sets the second argumentth item of the array to the first argumentth item of the array (the first argumentth item stays the same), and the sum instruction sets the 0th item of the array to the sum of the 1st, 2nd, 3rd, and 4th items of the array. The instructions in the program are executed cyclically until the program halts (see #Halting). Executing move with a negative first argument sets the second argumentth item of the array to a number input by the user (0 on EOF), and a negative second argument outputs the first argumentth item in the Array, but if both arguments are negative, then nothing happens.
==Halting==
A Movesum program will halt if the array doesn't change after two commands are executed (including move with two negative arguments). Programs can be forcibly halted by typing the following:
 move 0 0
 move 0 0
==Examples==
===Hello World ASCII values===
 0=72 1=101 2=108 3=111 4=32 5=87 6=114 7=100 8=1 9=2
 move 0 -1
 move 8 10
 move 1 -1
 move 9 10
 move 2 -1
 move 8 10
 move 2 -1
 move 9 10
 move 3 -1
 move 8 10
 move 4 -1
 move 9 10
 move 5 -1
 move 8 10
 move 3 -1
 move 9 10
 move 6 -1
 move 8 10
 move 2 -1
 move 9 10
 move 7 -1
 move 0 0
===Infinite numeric cat===
 1=2 2=1
 move -1 0
 move 1 3
 move 0 -1
 move 2 3
===Cat until EOF (0)===
 2=1 3=2
 move -1 0
 move 2 4
 move 3 4
 move 0 -1
 move 0 5
 move 1 5
===Add two inputs===
 1=42 2=42
 sum
 move 0 -1
 move 0 0
===Truth-machine===
 0=42
 move 0 -1
 move 0 1
 move 2 1
==Implementations==
A Python interpreter by User:Bangyen.
Category:Languages Category:2020 Category:Implemented Category:Unknown computational class
Movi

Movi is an esoteric programming language designed by User:Yousurname in 2022. It is a one-instruction language inspired mainly by the mov instruction.
The instruction Movi uses two operands:
 A B
in which the value at the address at address B is copied into the value at the address at address A. In C-like syntax, it performs **A = **B;. It is meant to be a simplified version of the mov instruction that only operates indirectly. Programs and data exist in the same uniform address space, i.e. the program operates on itself and is self-modifying. Programs are written as a list of numbers separated by non-numeric characters, and the program is executed in pairs of numbers. A command is skipped if B does not exist or A, B, *A, or *B is outside the program's range. The program is run in an implicit loop for control flow.
== Example program ==
 0 3 9 4 42
This program sets the first data value to 42 and then does nothing. The program starts with the first pair of numbers, 0 3 and executes **0 = **3, which is equivalent to *0 = *4, which sets the first data value to the fifth data value, which is 42. Then the progrm moves on to the next two numbers, 9 4, but skips them because 9 points to outside the bounds of the program. Then it moves on to 42 and skips it because B does not exist. Finally, it moves back to the first pair of numbers, which is now 42 3 and skips it because 42 points to outside the bounds of the program. Here it enters an infinite loop where all instructions are skipped.
== Simplification from mov ==
The mov instruction is Turing-complete in a program that loops forever (see the mov page), but despite being only one instruction, it can take a variety of different parameters, like so (where r1 and r2 are registers and n is an immediate value):
* mov r1, n
* mov r1, r2
* mov [r1], n
* mov r1, [r2]
* mov [r1], r2
with the option to include an offset in the brackets.
Movi aims to simplify these into one type of instruction, performing, in essence, mov [x], [y] where x is [a] and y is [b].
== Computational class ==
Movi bears resemblance to mov (but does not support offsets) and to ByteByteJump (but does not jump), making it likely to be a Bounded-storage machine, but no proofs have been made. If you believe you have sufficient proof, please update this section.
== See also ==
* OISC
* Mov
* ByteByteJump
Category:Languages Category:Low-level Category:OISC Category:2022 Category:Unimplemented Category:Self-modifying Category:Bounded-storage machine Category:Cell-based
Movielength

Movielength is a language where every command is a video (video includes sound). If a color channel of a pixel in one frame of a program is off, even by 1, the program wipes all memory from the computer other than the running Movielength and then bricks your computer. If it fails to do this, it will instead download all of the illegal content it can find and shares it with all your contacts. Despite this, Movielength isn't that dangerous, as any computer with any antivirus at all will stop it from gettting on your computer. Movielength, pronounced exactly the same & lowercased mid-sentence, does not have this threat and will instead crash, and thus is downloadable & safe.
==Commands & workings==
Movielength is similar to brainfuck, exept it takes place in infinite dimensions, each cell can hold any complex number, and each cell starts with 1:
Video 	Action 	Text notation
Never Gonna Give You Up by Rick Astley 	Go foreward 	n
The Bee Movie from Dreamworks Animation 	Go backward 	b
A Couple of Tungsten Cube Reviews by Jeaney Collects	Go up* a dimension 	t
Any Minecraft Let's-Play video 	Go down* a dimension 	m
10 Hours of Silence by anyone 	Increase by the cell from behind 	s
Baby Shark (the famous YT one) 	Multiply by i & subtract 1 from magnitude** 	f
Any video with multiple trampolines and sad music 	Jump to place in code corresponding with selected cell's rounded magnitude	w
Any video with a single trampoline and sad music 	Get number from user if on real number, else print real component 	v
*More like rotation becuase of nonpositive dimensions, **Negative magnitudes can happen, in which case increase phase by pi & make magnitude positive.
The text notation is not legal code, but it has to be used in this text-based page to say anything.
Category:Languages Category:Cell-based Category:Non-textual
Moving donut

Moving donut is based off Mice in a maze and HQ9+.
==Commands==
The BF commands are the same, every lowercase letter prints itself, O is the donut, A toggles ASCII output mode for BF commands, and # is the wall.
==Donut movement==
The donut moves right until it hits a wall, than it rotates clockwise and tries again.
==Examples==
===Hello World===
 ######
 #dlro#
 ######w#
 #Ohello#
 ########
===Cat===
 ########
 #O+[,.]#
 ########
===Truth machine===
 ####
 #.]#
 ##.#
 #[#
 #,#
 #OA#
 ####
===Moving donut is a very interesting language===
This program concocts a meandering plan in its pursuit to state the message “movingdonutisaveryinterestinglanguage”.
 ##############
 #Omovingdonut#
 # ######i#
 # #yrevas#
 # i######
 # n#
 # t#
 # e#
 # r#
 # e#
 # s#
 # t#
 # i#
 ## n#
 #augnalg#
 #g######
 #e#
 ###
==Interpreter==
* Common Lisp implementation of the Moving donut programming language.
Category:Two-dimensional languagesCategory:LanguagesCategory:2023Category:Turing completeCategory:Implemented
Mox

Mox is another cell-based esolang by User:Infinitehexagon with a short amount of instructions. Mox is made out of the letters in ther title plus a few extra instructions too. Mox is also a derivative of X strike.
Category:LanguagesCategory:2024Category:Cell-basedCategory:Turing complete
== Instructions==
Instructions	Description
m 	shift the memory pointer right
o 	shift the memory pointer left and decrement the value under the cell by one.
x 	input a value into the current cell modulo 256.
!a 	output cell a as an ASCII character modulo 256. (if argument a is blank, then the first cell / cell 0 is outputted.)
ga,b 	jump to line a in the program until the cell under the memory pointer is greater than b.(leave b blank to go to line a while not 0.)
i 	increment the current cell by 1.
~a 	output cell a as an decimal number modulo 256. (forgot to add this one)
=== Cat program ===
 x
 !
=== Addition program(?) === 
 x
 m
 x
 o
 i
 i
 m
 m
 o
 g4,
 ~0
===Hello world program ===
 i
 g1,71
 ~0
 i
 g4,100
 ~0
 i
 g7,107
 ~0
 ~0
 i
 g11,110
 ~0
 m
 i
 g15,43
 ~1
 m
 i
 g19,31
 ~2
 i
 g22,86
 ~2
 i
 g25,110
 ~2
 i
 g28,113
 ~2
 m
 i
 g32,107
 ~3
 m
 i
 g36,99
 ~4
 m
 i
 g40,32
 ~5
==Computational class==
Using X strike's turing complete proof of translating the instructions to brainfuck, we can translate Mox to brainfuck.
>:
 o
 i
<:
 m
[]:
 code...
 gn,
+:
 i
-:
 m
 o
,:
 x
.:
 ~n
Muddle

Muddle is a programming language which was meantto be stack-based, but ended up tape-based, was meant to interpret in Python 2.7 but ended up interpreting into Python 3, was meant to be Unimplemented, purely conceptual, but ended up being designed while writing a interpreter for it. It was meant to be revealed on IRC, but The author started disliking IRC, so it was released directly to the wiki.
==Commands==
Muddle is quite hard to explain. So, let me clear some stuff up: c is the tape, the pointer points to a cell on the tape.
Command "*" is followed by a number or string. * puts that number of string into the tape(c). * is a useful command.
> decreases the pointer variable. < increases the pointer variable. ! prints the whole tape. ^ prints the cell on the time with index = pointer. ? erases all the tape. If you dont understand the definitions, look at the code of the interpreter. NB: between every command is a space. 
==Example programs==
Hello world:
* Hello * World! !
It pushes Hello into the tape and then pushes World! into the tape, making the tape look like this: [Hello, World!]. Then ! outputs [Hello, World!]. 
Pointer Peculiarities:
* hello * world < < ^
First, it pushes hello, then world, increases pointer 2 times(by default pointer = 0). This employs wrap-around, as c[2] is c[0](Our tape has ended at c[1]). So the output is hello. Warning: 
No control flow exists in Muddle. No Looping is available. So Truth-machines are impossible. '''
==Computational class==
There is no input, there is no control flow. A truth-machine can not be simulated in it. Looks like it is Turing-incomplete!
Note: This language is meant to be Turing-incomplete to study the bounds of computation. A Essay, On Computing bounds of Computation, Using a Example Turing-Incomplete Language(OCBCUETIL) is being written along side Currency exchanges and computation(CEC).
==Interpreter==
See: 
Category:Languages
Category:Unknown computational class
Category:2018
Category:Implemented
Muddle++

Muddle++ is version of Muddle which looks even more weird! It manages to add a second tape, which reads from the first tape, and then pushes itself to the main tape. Don't understand? Read the code of the interpreter!
===Commands added===
Read: pushes the data in the cell under the pointer to tape 2.
Xtc: Tape 2 pushes itself to tape 1.
===Computational class===
Pure Muddle is suspected to not be Turing-complete.
===Examples===
* hello * world read xtc !
Any others?
===Go to===
Muddle
Category:Languages Category:Cell-based
Mugh brains

mugh brains is a zombie-themed (joke) language designed by a zombie[user ns].
==Example Program==
===Pseudo Hello, world! program===
 get brains
 muhh
 gurgh
 uh
 moan
 groar
 bluhh
 moahn
 eat brains
This prints this:
 Hello, world! Wait, what's that? OH NO A ZOMBIE!! AAAA-- *brains get nommed*
==How it *brains* works==
Exactly how mugh brains works is a mystery. Maybe we'll find out when we find the cure for the zombie virus... Nah.
Category:Languages
Category:Unimplemented
Category:Joke languages
Category:Usability unknown
Category:2009
Category:Unknown computational class
Category:Thematic