nyuuzyou/wikis huggingface dataset:
Mierda

Mierda (spanish for Fuck) is a brainfuck substitution language. Each command is changed to be the Spanish translations of the actions that they produce.
==Commands & Translations==
Brainfuck	Mierda 	English
Mas 	Plus 	
Menos 	Minus 	
> 	Derecha 	Right
< 	Izquierda 	Left
. 	Decir 	Print (or say)
, 	Leer 	Read
[ 	Iniciar Bucle 	Start loop
] 	Terminar Bucle	End loop
==Hello, World!==
 Derecha Mas Mas Mas Mas Mas Mas Mas Mas Mas Iniciar Bucle Izquierda Mas Mas Mas Mas Mas Mas Mas Derecha
 Menos Terminar Bucle Izquierda Decir Derecha Mas Mas Mas Mas Mas Mas Mas Iniciar Bucle Izquierda Mas Mas
 Mas Mas Derecha Menos Terminar Bucle Izquierda Mas Decir Mas Mas Mas Mas Mas Mas Mas Decir Decir Derecha
 Derecha Derecha Mas Mas Mas Mas Mas Mas Mas Mas Iniciar Bucle Izquierda Mas Mas Mas Mas Derecha Menos
 Terminar Bucle Izquierda Decir Derecha Derecha Derecha Mas Mas Mas Mas Mas Mas Mas Mas Mas Mas 
 Iniciar Bucle Izquierda Mas Mas Mas Mas Mas Mas Mas Mas Mas Derecha Menos Terminar Bucle Izquierda Menos 
 Menos Menos Decir Izquierda Izquierda Izquierda Izquierda Decir Mas Mas Mas Decir Menos Menos Menos Menos 
 Menos Menos Decir Menos Menos Menos Menos Menos Menos Menos Menos Decir Derecha Derecha Mas Decir Derecha 
 Mas Mas Mas Mas Mas Mas Mas Mas Mas Mas Decir
Category:Languages Category:Brainfuck derivatives Category:Brainfuck equivalents Category:Turing complete Category:Turing tarpits Category:Pseudonatural
Mihaieso esomixup

mihaieso esomixup is a language by user:tommyaweosme designed to have one aspect from every single one of user:mihaieso's esolangs.
== commands ==
 trap - stops the program
 Bad command or file name - prints "Bad command or file name"
 NameError - prints "Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
 NameError: name '[command]' is not defined"
 w - prints "Hello, world!"
 H - prints "Hello, world!" (to the console)
 pas - pauses program until next key pressed
 bl - prints newline
 Bluetooth mode. - clears screen
 "???"> - prints what "???" is replaced with
 ! - crashes the PC with an infinite loop (doesnt crash phones or laptops)
 add - adds two random numbers and doesnt show the output. basically a nop, but uses a miniscule amount of processing power
 say! - prints "text" repeated until the end of the line
 111 - prints the entire program and stop. this makes an infinite number of quines
 SGVsbG8sIHdvcmxkIQ - prints "Hello, world!"
 https://pastebin.com/YREyS9Gr - prints "Hello, world!"
 Skibidi Toilet - prints "Skibidi Toilet"
 ❔Variable	- saves user input into the current brainfuck cell (alternative of 行)
 FIZZLANG - prints "fizzbuzz" a random number from 1-100 times
these commands can also be written in tables where one letter is one row.
 
=== ____fuck series ===
 1 >
 2 <
 Y/Yoshi +
 C/C#/D/Captain Toad -
 还 .
 行	,
 Calculator [
 Reversi ]
=== translated ____ series===
 Vplay ??? - prints what "???" is replaced with
 New Line ??? - prints what "???" is replaced with
 Show mailboxes - nop
 Q - also nop (would be curly braces, but dont actually belong to any loops)
 Define !!! - makes a new command, which is what "!!!" is replaced with, which is a quine
 Function to calculate domain size - nop
Category:Languages Category:Joke languages Category:Turing complete
Milk

== Milk ==
A concept for the milk language created by Salmmanfred (talk)
=== Concept ===
Milk 
Add milk - adds milk to the carton a variable that controls the interpreters urges
Pour text - print
pour yoghurt index - print var
Yoghurt value - add to the stack
Cheese +|-|/|* (index) (index) - math
Get milk - get the input from user
Check milk - if
Spoil milk - stop if
. - end of line
Depending on the amount of milk the lang does stuff too little and it quits too much and it barfs and changes the latest used var to less milk thanks.
=== Implementations ===
milk.c
Category:Languages
Category:2021
Category:Total
MinISCule

MinISCule is an esoteric programming language created by Jeffry Johnston in 2006, with the goal of having a very small interpreter for a Turing-complete language. The interpreter is in MS-DOS COM binary format and is 36 bytes in size. It was written using DEBUG, so the source listing is made from a program disassembly.
The language is an OISC variant, with instruction pointer (IP) and memory pointer (MP). Instructions take the form aaaavvjjjj, where `a' is address, `v' is value, and `j' is jump. Programs are read from stdin, and are separated from their input by a single CR character (0D hex/13 dec).
To maintain an ASCII input source, input characters are decreased by 78. This means that the space character represents the value -46, the uppercase N = 0, and tilde (~)= +48. Use of characters outside this range is accepted, but discouraged.
An instruction is processed as follows:
# MP += address (LSB then MSB)
# If value == 0 then perform an MS-DOS system call:
## Sets registers: AX = address, DL = byte at MP
## Executes the INT 21h system call (exit: AX = 00xx, read stdin: AX = 01xx, write stdout: AX = 02xx. See Ralf Brown's Interrupt List for more)
# byte at MP += value (or AL return value from a system call)
# IP += 5
# If byte at MP != 0 then IP += jump (LSB then MSB) 
Note that IP is interpreted using byte offsets, not in terms of 5-byte instructions, so to skip an instruction, use jump = 5, not jump = 1. Setting jump = 0 results in execution always being passed to the next instruction.
==Examples==
* Simply exit
 NNNNN
* Print the character `A' and exit
 NPONNNNMIMNN~NNNN_NNNLONNNNMNNNPNNNNNNNN
==See also==
* Barely
==External resources==
* MinISCule interpreter binary (MS-DOS)
* MinISCule interpreter source listing
* Bootable FreeDOS disk image, with MinISCule, Barely, FreeDOS Debug
* 8088 assembly language book
* MS-DOS DEBUG reference
* MS-DOS COM binary format. 
* IBM PC and MS-DOS interrupt list
Category: Languages
Category: Implemented
Category: Turing complete
Category: 2006
Category: Turing tarpits
Category: Low-level
Category: OISC
Minaac

Minaac (Minaac Is Not An Assembler Clone), made by User:TheJebForge, is a run-time interpreted esoteric programming language capable of recreating a Turing machine making it a Turing-complete language.
The language is similar to machine code by syntax, but it's not a clone. You'll understand why when you'll try it. It requires C++11 to run.
It can be integrated into any C++ program and have custom functions and buffers to be used with that specific program.
== Example code ==
Way to print "Hello world!" is
 buf 0x1 out
 put 0x1
 mov 13 0x1
== External resources ==
Further information about the language can be found at the repo on GitLab.
Category:Languages Category:2019 Category:Cell-based Category:Turing complete Category:Implemented Category:High-level
Minasm

minasm is designed by osminee in 2020. It's more like serious assembly language, however it has weird notation and lack of basic operations.
== The machine ==
minasm machine have unbounded memory of unsigned integers. The processor has four registers: A Register (AR), B Register (BR), C Register (CR) and Operation Register (OR). AR, BR and CR are used to store data and for subroutines. Operation Register (OR) also stores data, but it can only be accessed by COP instruction. OR is used basically for conditional jumps. minasm has also registry called Instruction Pointer (IP), however it cannot be changed via instructions (except jump commands, which are the only way to change the value of IP).
== Syntax ==
Let's demonstrate the basics of minasm on this simple program:
 ` example program `
 COP OR 6
 ADD (1) -1
 JNZ (0)
 TER
First, all comments are removed (marked with `<comment>`). First instruction, COP OR 6 is like MOV instruction in x86 assembly: it COPies second argument to first one. So COP OR 6 copies value 6 to the Operation Register (OR).
The second one, ADD (1) -1 ADDs second argument to first. In this example it adds value -1 to address 1 in hexadecimal, so it actually subtracts 1 from this address (parenthesis are used to denote that this number is physical address). Also, if you notice, this points to 6 in COP 6 OR, because COP takes 1 byte, as well as 6 and OR. Index of first value is 0, so 0+1=1.
Next is JNZ (0). It jumps to specified byte if OR value is not zero. In this example, we initialize OR with value 6, so this condition would be satisfied and it would jump to byte 0.
Last command is TER. It exits from program.
So basically this initializes Operation Register with value 6. Then it subtracts 1 from location 1 (pointing to 6), so it becomes 5. Then it checks if value in OR is not zero. If yes, then it goes to the beginning of the code. Else, it terminates the program.
== Instructions ==
Here are all instructions.
Name 	Usage 	Description
COP (COPy) 	COP <destination> <source>	Copies <source> to <destination>
ADD (ADD) 	ADD <destination> <source>	Adds <source> to <destination>
JMP (JuMP) 	JMP <byte> 	Jumps to specified byte in program and continues execution of program from that byte
JZ (Jump if Zero) 	JZ <byte> 	Checks the value in OR: if it's zero, jump to specified byte; else, continue execution of program normally
JNZ (Jump if Not Zero) 	JNZ <byte> 	Same as JZ, except it jumps if value in OR is not zero
TER (TERminate) 	TER 	Ends program
SUB (SUBroutine) 	SUB <number> 	Calls a subroutine (subprogram) with number <number>
DAT (DATa) (deprecated)	DAT <number> 	Variation of COP: it gets replaced in code by <number>
== Subroutines ==
Subroutines are built-in functions that are used to shorten code.
Category:Languages
Category:2020
Minceraft

Minceraft (not Minecraft) is an esolang that stems from a single premise: What if your Minecraft world was a computer program?
This language's name is Definitely not a mistake and Absolutely a reference to Minecraft's Easter egg of the same name and In no case whatsoever a typo made when creating the language.
As the language is in early stages right now, this page is quite barebone. But, in the near future will come a compiler/interpreter (probably interpreter to be honest), and more information. I swear its true. Belive me.
Category:Ideas
Category:Languages
MindFuck

MindFuck is a BrainFuck inspired language.
The difference between the two is that in MindFuck it's all manual.
So basically MindFuck is “if BrainFuck was almost useless”.
=== Commands ===
() initialize section
{} initialize cell:
* | and | cell selector
* = cell modifier
* [ and ] loop cell (stop if cell number is 0)
* + add 1
* - remove 1
* < and > previous and next cell
* ! output number
* . output character (ascii)
* ; input character (will be converted in ascii)
* , input (only number)
\ and / next and previous section
=== () and {} ===
While using MindFuck, you should start the program with a section by using “(“ and “)”.
In a section you can use an infinite number of cells, which you can create with “{“ and “}” or by directly selecting them with “|” and “|”.
Example 1:
({}) <- i started by creating a section and then inside of it i created a cell manually.
Example 2:
(|0|=) <- i created a cell by directly selecting it with its selector number.
=== Coding ===
Now that you know how to make a section and create cells, we should start coding.
If you want to code in MindFuck you should know how to code in BrainFuck, because it’s the same thing but with more nonsense in it.
For example i will write a program that adds two numbers together and then it prints the result:
({,} {,} |0|= [>+<-] |1|= !)
Input cell 0: 3
Input cell 1: 8
{3}{8} -> {3}{9} -> {2}{9} -> {2}{10} -> {1}{10} -> {1}{11} -> {0}{11}
Output cell 1: 11
Category:Languages Category:Brainfuck derivatives Category:Cell-based
MindReadingFuck

MindReadingFuck
is a joke esoteric language created by User:Dart in 2019. It is loosely a brainfuck derivative.
==Description==
MindReadingFuck is very easy to program in, as there are zero valid instructions.
The way every MF program works is that the interpreter knows exactly what the user wants. It doesn't involve actual mind reading, it's just every single use of MF is pre-determined. In fact, it even knows exactly which inputs you will make, so you don't need to waste your time typing them in. There is no output though, since it's not required for turing-completeness.
The only possible error that can occur is unexpected symbol.
==Computational class==
It's hard to compare instructions one by one, but here's a BF interpreter written in MF:
  
So the class is turing-complete or even greater. It's also the ultimate turing tarpit and BF instruction minimalization, that needs only zero instructions and zero symbols.
More recent proof shows the real class is uncomputable though.
==Examples==
====Hello, World!====
  
And the minimized version:
  
====Self-interpreter====
  
Fun fact: it's the only interpreter.
====Quine====
  
====Palindrome "Hello, world!"====
  
====Solve the halting problem====
  
====Busy Beaver Function====
  
Category:Languages
Category:Joke languages
Category:Uncomputable
Category:Brainfuck derivatives
Category:2019
MindScuffed

== Mind Scuffed ==
Mind Scuffed is just an "improved" brainfuck clone
== Configurable ==
 Config
Name 	Function 	Default
CELL_MAX 	Max value a cell is allowed to have	255
CELL_SIZE	the amount of cells 	15
 Instructions
Instruction 	Function
> 	move pointer to right
< 	move pointer to left
+ 	increments cell's value by 1
- 	decrements cell's value by 1
: 	sets the cell's value to CELL_MAX
; 	sets the cell's value to 0
. 	prints the cell's value
, 	takes an i32 as user input
[ 	enters a loop if cell is not zero
] 	jumps to front of loop
* 	multiplies the cell's value by the cell right of the current, then sets the cell to the right to 0
/ 	divides the cell's value by the cell right of the current, then sets the cell to the right to 0
& 	adds the cell's value to the right of the current cell, then sets the cell to the right to 0
~ 	sets current cell's value to a random number between 0 and CELL_MAX
\ 	subtracts the cell's value to the right of the current cell, then sets the cell to the right to 0
l (lowercase L)	prints a list of all cell's value's
== Example ==
 ++++++++>++</.l
=== will output: ===
 4
 | 4 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
=== Rust Interpreter ===
 https://github.com/Bryson-C/BrainFk_interpreter/tree/main/MindScuffed
Category:Languages Category:Implemented Category:Brainfuck derivatives
Mindcrush

Mindcrush is a Brainfuck derivative created by IAmAPersson in 2013 and implemented in SmileBASIC for Petit Computer. It can be downloaded (sort of) on its page at the Petit Computer Wikia.
==Language Definition==
Mindcrush has 9 commands:
Command	Meaning
+ 	Increase the number in selected cell by one
- 	Decrease the number in selected cell by one
> 	Increase the pointer
< 	Decrease the pointer
[ 	Marker for ]
] 	Jump to the matching [
& 	Returns a result of the status of cell1
/ 	Output cell; if cell in empty, get input
. 	Used as a marker in the case of a program error2
1If the selected cell is zero, jump to the nearest dot (.) AKA return an error. You can add +s or -s after the & to define a number. For example, &++ means "If the selected cell is two, jump to the nearest dot."
2If an error occurs in the program (like trying to go to cell -1 or cell 32,001) then the program will jump to the nearest dot (.) and continue to execute the program.
Each cell, when output, will display a specific character. Below is a list of characters (it does not operate on ASCII):
 Z Y X W V U T S R Q P O N M L K J I H 
 -27 -26 -25 -24 -23 -22 -21 -20 -19 -18 -17 -16 -15 -14 -13 -12 -11 -10 -9 
 
 G F E D C B A newline input 1 2 3 4 5 6 ...
 -8 -7 -6 -5 -4 -3 -2 -1 0 1 2 3 4 5 6 ...
==Program examples==
The obligatory Hello World example:
 ------>------------->------------------------>-<<<+++/---/>//---/>/</---/<++++++/[>].-----/[]
CAT program:
 [/&+ ->].[<].[/>].[]
Category:Languages
Category:brainfuck derivatives
Category:Low-level
Category:Cell-based
Category:2013
Mindshit

Mindshit is a Brainfuck derivative by CosmicMan08#1975 (User:CosmicMan08), it's unique in the fact that it has a character that switches the meaning of all other characters.
== Instructions ==
Instruction	Mode 1 	Mode 2
> 	Move pointer right 	Move pointer left
+ 	Increment value at pointer 	Decrease value at pointer
. 	Output value at pointer as ascii 	Take the user's input and puts it as ascii in the value at the pointer
! 	Sets mode to 2 and hops forward 5 times in the program tape 	Sets mode to 1 and hops backward 5 times in the program tape
# 	Hops forward 2 times 	Hops backward 2 times
? 	Acts like # if the value at the pointer is 0, otherwise the instruction is ignored	Acts like mode 1.
Just like brainfuck, all other characters are ignored.
In addition to the meaning switch, mode 2 also goes right-left instead of left-right.
==See also==
*Brainfuck
Category:Languages
Category:Brainfuck derivatives
Mindwhipper

Mindwhipper (stylized mindwhipper, previous planned name: *sswhipper) is a esoteric programming language created by User:Asasnat, who also created this article. Mindwhipper was inspired by Brainfuck. (in fact, I think it could be regarded as an actual Brainfuck clone, I don't know. But I highly doubt it, because the instructions set is very different.)
== Commands ==
Mindwhipper contains 10 basic commands:
> - moves memory tape pointer to the next slot
< - moves memory tape pointer to the previous slot
+ - increments the currently accesed memory tape slot
- - decrements the currently accesed memory tape slot
] - increments the currently accesed memory tape slot by 10
[ - decrements the currently accesed memory tape slot by 10
; - prints the currently accesed memory tape slot's value
. - transforms the currently accesed memory tape slot's value into an ASCII character and then prints it onto the screen
/ - prints a new line
' - resets the currently accesed memory tape slot to zero
== Examples ==
Classic "Hello, world" program, painstakingly written by the creator himself:
 ]]]]]]]]]]++++.']]]]]]]]]]+.']]]]]]]]]]]--..']]]]]]]]]]]+.']]]++.']]]]]]]]]]]]-.']]]]]]]]]]]+.']]]]]]]]]]]++++.']]]]]]]]]]]--.']]]]]]]]]].'
Note: it actually outputs "hello world" all in uncapital letters.
==IMPORTANT NOTE!==
This language hasn't been finished yet. In fact, I doubt it could even be called a language, because currently, there are NO LOOPS. Not even input. So, just be patient and wait until I update it.
Category:Languages
Category:Low-level
Category:2020
MineScript

::The creator of this esolang did leave from esolangs wiki, continue page for yourself
MineScript is a esolang inspired on the game Minecraft.
== Rules ==
# There is an accumulator called 'XP'
# Every instruction take a time to run
== Instructions ==
What is 	What does 	Time to run
kill mob 	Increment XP 	1 second
get sword 	If you kill mobs and you got the sword, you XP will incremented by 5 	1 to 3 seconds
drop sword 	Drop the sword 	nothing
enchant 	Will push XP to the top of the stack 	1 second
find mountain 	Go to a mountain 	1 to 5 seconds
jump to ground	If you are in a mountain, your XP will be set to 0 	1 second
denchant 	XP will be set to the top item of the stack and then will pop the top item of the stack	1 second
unicode sign 	Dup the top item of the stack 	1 second
add 	Will pop the last top two items of the stack and push the result of his addition 	1 second
unicode sign 	Dup the top item of the stack 	1 second
unicode sign 	Dup the top item of the stack 	1 second
unicode sign 	Dup the top item of the stack 	1 second
unicode sign 	Dup the top item of the stack 	1 second
unicode sign 	Dup the top item of the stack 	1 second
unicode sign 	Dup the top item of the stack 	1 second
Category:Languages Category:Thematic
Minebit

Minebit is a programming language invented by User:TehZ. It is designed in a way easily implementable in Minecraft using redstone and linear access memory.
== Language ==
There are only two commands:
 0 - if current bit is 0, skip next command
 1 - flip current bit
It uses linear access memory, so each step, a new bit is made available. That means that it needs finite memory. It can, however, also mean that it can have unbounded program area, if the program is fed to the machine. In other words, it has two bit-tapes; the program tape and the data tape.
== Implementation ==
It can be implemented using a few logic gates. Note:
 =V- means or
 =^- means and
 =o- means xor
 -L- means linear access memory
 -N- means not
 + means cross
NOTE: This implementation is not timed. If you implement it (like I have done) you need careful timing.
 .------------------.
 *-L---:=V-.----:=o-*
 | | |
 .-L-.-*----:=^-*
 *---*
The linear access memory can be implemented by an array of repeaters.
== Computation class ==
The language is not Turing complete because it has limited memory, and even if it was modified to have infinite memory, it is still equivalent to a read-only right-moving Turing machine, which is equivalent to a finite state machine.
Category:Languages
Category:2016
Minecode

Minecode is an esoteric programming language where you "mine" and find various ores that do things. You also have a Miner's log, which has infinite pages, and infinte data can be stored on one page.
==Writing Types (Data Types)==
You can write with:
* A crayon (Random number from 50 to 100)
* A pen (Number)
* A pencil (String)
==Commands==
 find(ore) - Finds a specific ore.
 dig_down - Changes the rarity by 1.
 dig_up - Changes the rarity by -1.
 log(page,writing_utencil,storage) - Logs something with a specific writing utencil on a specific page. Third value is omitted when crayon used.
 go_page(page) - Goes to a specific page in the log (Points to a specific data area).
 repeat(times)[] - Repeats something a certain number of times.
 forever[] - Does something forever.
 if(boolean)[] - If
 while(boolean)[] - While
==Ores==
Note that once your rarity goes higher than a certain value, you can still access the ores that are below your rarity value. You start with rarity 1.
===Rarity 1===
 Copper - Prints current page
 Iron - Asks for input, and saves to current page
===Rarity 5===
 Bronze - Goes to the line of the current page value. If page is a string, be a nop command.
 Granite - Skips the next line
===Rarity 10===
 Gold - Terminate the program
 Ruby - If there is a math problem on the current page, solve it and replace the current page with the answer.
===Rarity 15===
 Diamond - If the page is a number, square it.
===Rarity 20===
 Obsidian - The glitched ore. Once you find it, if it is on line 43, it unlocks plushie(). If it is not on line 43, then it crashes your computer with a BSOD.
===Plushie command===
 plushie(food) - Eats the food inside of the brackets.
==Hello World==
 log(1,pencil,Hello world!)
 go_page(1)
 find(copper)
==Truth Machine==
 go_page(1)
 find(iron)
 if(currentpage=1)[
 forever[
 find(copper)
 ]
 ]
 if(currentpage=0[
 find(copper)
 repeat(9)[
 dig_down
 ]
 find(gold)
 ]