nyuuzyou/wikis huggingface dataset:
MSFE++

== Introduce&Syntax ==
It is an extended version of MiniStringFuck.
Changed from only 2 operators to 3.We also added 2 bytes.Here are three operators in MSFE++.
+ operator: used to add one to the current byte.
- operator: new operator. Subtracts the current byte by 1 and moves to the next byte. If executed at the last byte, moves to the first byte.
Asterisk (*) operator: Iterates through the contents until the byte is 0.
Three minuses will output the current byte. Four will input the current byte.
== Examples ==
Some examples here.
=== XOR Gate ===
 ++-++-+-*-++-+-*+--+-+--+-+-*+++-*
++- is 1, +- is 0.
you can change ++-++- to other things.
=== Cat program ===
 +*----++-++-++-++*
=== NOT Gate ===
 +-+-+-*+++-*
About the first character: + is 1, delete the + is 0.
Result is in the first byte.
== Interpreter ==
And there is an interpreter.
a = [0,0,0]
o = 0
m = 0
def itp(c):
 global a,o,m
 r=0
 for j,i in enumerate(c):
 #print(i,a,o)
 if r==0:
 if i=='+':
 a[o] += 1
 m = 0
 elif i=='-':
 a[o] -= 1
 o += 1
 o = o%3
 m += 1
 if m==3 and (c[j+1]=='-' if j+1<len(c) else 0):
 a[o]=ord(input()[0])
 if m==3:
 print(chr(a[o]))
 if m==3 and c[j+1]=='-':
 a[o]=ord(input()[0]) 
 elif i=='*':
 m=0
 while a[o]!=0:
 itp(c[j+1:j+1+c[j+1:].index('*')])
 if i=='*':
 r=(r+1)%2
itp('++-++-+-*-++-+-*+--+-+--+-+-*+++-*')#1 XOR 1. Result is in the second byte.
#print(a)
I think it is like BrainFuck,but,It isnt an unary...
smile everyday.
Category:Languages Category:Unusable for programming Category:2024 Category:Implemented Category:Brainfuck derivatives Category:Total
MSG

MSG is an esoteric programming language/virtual machine by User:Twistle. It depends entirely on three things: messages, objects, and wires.
==Grammar==
There is one object initiated at the beginning, named main. There is also an engineer object, which we'll get to later. The form of a command is as follows:
 <object> '<message>' <wire>
this sends <message> to <object> along <wire>.
There are three built in wires, named stdin, stdout, and stderror. These all hook up to main
==Messages==
Messages have two parts: the general, and the specific.
These are the messages that main respond to:
 create <object>
 passon <object> <message>
These are the messages that engineer respond to:
 wire <id> <object1> <object2>
 exit
 delete <object>
create creates an object named <object>
passon passes <message> to <object>
wire creates a wire refered to as <id> which connects <object1> to <object2>
exit closes everything up.
delete deletes <object>
==Example==
 main 'passon stdout 'Hello, world!' '
 main 'passon engineer 'exit' '
MUSYS

MUSYS was an early music synthesis language designed by Peter Grogono for EMS in London in the early 1970s for composing and performing electronic music. "The heart of MUSYS is a simple yet powerful macroprocessor", an idea influenced by the paper "A General Purpose Macrogenerator" by Christopher Strachey. The more general purpose language Mouse later evolved from it.
MUSYS was designed to run programs on EMS' two DEC PDP-8 minicomputers. Electronic music compositions using MUSYS were publicly performed in London in the early 70s in venues such as Queen Elizabeth Hall. The language was awarded a 1,000,000 lire prize for Electronic Music Software by Radio Milano in 1972.
==Examples==
===Historical===
Macro:
 NOTE O1.%A. A1.%B. E1.%B/2+7. T1.%C-1. E1.%B/2+2<7. T1.1. T=T+%C @
Single note composition using the above macro:
 #NOTE 56, 12, 15;
 $
===Contemporary===
 1"HELLO, WORLD!" $
"TRUTH MACHINE"
A=1
1 A"1"
A[G1]
1"0"
$
"COLLATZ SEQUENCE"
A=25
10 A-1[A&1[A=A*3+1*2] A=A/2 \ G10]
$
==References==
* Strachey, C., "A General Purpose Macrogenerator" Computer Journal, vol. 8 1965, pp. 225-241
* Grogono, P. "MUSYS: Software for an Electronic Music Studio" Software — Practice and Experience, vol. 3 1973, pp. 369-383. doi:10.1002/spe.4380030410
==External resources==
* Peter Grogono's EMS page describing MUSYS
* Mouse article in BYTE magazine, July 1979, vol. 4, number 7, which briefly describes MUSYS.
* "A General Purpose Macrogenerator" article (PDF available via link)
* MUSYSim In progress MUSYS simulator project (Python / Nyquist)
Category: Languages
Category: Before 1993
Machine code

Machine code is the native language of a computer processor. A computer can execute machine code without the need for an interpreter or compiler, whereas other languages are translated into machine code either directly - before execution using a compiler or during execution using an interpreter - or indirectly - compiling to a language for which a compiler or interpreter already exists.
Any programming language can be regarded as machine code for a hypothetical machine capable of executing its code directly, but this concept is particularly common for esoteric programming languages for which the construction of this hypothetical machine would be relatively straightforward, such as MISC.
==See also==
*Assembly code
==External resources==
*The Brainf*ck CPU - a CPU which uses brainfuck as machine code.
Category:Concepts
Macro

Macro is a programming language that uses macros to do computation
= Macro =
== Stuff to know ==
=== Macro ===
 a -> b #turn a to b
=== Selector ===
 ~a ~b ~a -> ~b ~a ~b #turns something1 something2 something1 to something2 something1 something2
=== Parenthesis ===
 5(4(3(2(1)))) #do inner parenthesis first, outer parenthesis last
=== Test ===
 do something #test the input "do something"
Category:Languages
== Examples ==
=== Print ===
print ~a -> ~a
print hello
Macron

Macron is an esolang by User:Heav.
One code point = 1 instruction. Instructions are read left to right. Non-instruction characters are ignored.
== Instructions ==
Instruction	Description
> 	Define a "macro". Implementation defined.
< 	Define a "macro". Implementation defined.
+ 	Define a "macro". Implementation defined.
- 	Define a "macro". Implementation defined.
. 	Define a "macro". Implementation defined.
, 	Define a "macro". Implementation defined.
[ 	Define a "macro". Implementation defined.
] 	Define a "macro". Implementation defined.
== Examples ==
 ++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.
Creates 106 macros.
Category:2021Category:Brainfuck_derivativesCategory:LanguagesCategory:Unimplemented
MadLad

MadLad is an esoteric programming language meant to be similar to C# but with a twist. MadLad is a very angry language and will yell at you for everything. Featuring screaming syntax and unhelpful error messages, this language hates everything and will express it with rage.
MadLad's syntax is meant to be angry. It is mad after all. Common C# syntax has been replaced by its angry counterpart.
==Syntax and examples==
 MadLad vs C# syntax
C# 	var 	if 	else 	while 	for 	true	false
MadLad	WHATEVER	BUTWHATFUCKINGIF	WHATTHEFUCKELSE	DOTHETHING	GOAROUNDPLS	FINE	NO
===A simple if statement===
 WHATEVER a = 3;
 WHATEVER b = "ahhhh";
 BUTWHATFUCKINGIF (a < 5)
 {
 PrintString(b);
 }
 WHATTHEFUCKELSE
 {
 PrintString("no");
 }
===Testing an even number===
 WHATEVER num = 10;
 WHATEVER isEven = NO;
 BUTWHATFUCKINGIF (num % 2 == 0)
 {
 isEven = FINE;
 }
 WHATTHEFUCKELSE
 {
 isEven = NO;
 }
===While vs for loop===
 WHATEVER x = 0;
 DOTHETHING (x < 10)
 {
 x = x + 1;
 }
 GOAROUNDPLS (int i = 0; i < 10; i = i + 1)
 {
 x = x + i;
 }
===Boolean logic===
 WHATEVER isLang = FINE;
 WHATEVER isGoodLang = NO;
 BUTWHATFUCKINGIF (isLang || isGoodLang)
 {
 PrintString("lang");
 }
Category:Languages
Category:2021
Category:Implemented
Mellobacon (talk) 10:23, 11 November 2021 (UTC)
Made up grammar rules

Made up grammar rules is an esolang based off the absurd (made up grammar rules).
== Commands ==
 a sentence ends with "" - print ""
 no sentence should start with "" - push "" 
 complete sentences have n words - push n to the stack
 the adjective never goes after a noun - pop and discard
 these grammar tips are good - pop and print
 a word should not have more than n letters - rotate first n of stack clockwise
 a sentence should have less than n letters - rotate first n of stack counterclockwise
 stay clear of these mistakes - clears stack
 never operation words together - does the operation to top two of stack first first second second (a stack 5 6 4 would be -1 4 from subtraction)
 no more of this, ok? - pushes user input
 please, dont do this: - goes to "ok?!" if 0
 ok?! - goes to "please, dont do this:" if not 0
 and never repeat yourself - duplicates top of stack
 please, no - prints "please, no"
== Hello World ==
 a sentence ends with "Hello world"
== Cat ==
 complete sentences should have 1 words
 please, dont do this:
 these grammar tips are good
 no more of this, ok?
 ok?!
== Quine ==
 please, no
Category:Languages Category:Stack-based Category:Thematic Category:Pseudonatural
Madeye

Madeye is a a model/modal programming language. It was created by User:Doesthiswork in 2017.
== Overview ==
Madeye is an attempt to borrow grammatical moods into a programming language. And why not modal logic too while we're at it. 
==Model Particles==
===Imperative===
 ! x = y
sets the value of x to y
===Interrogative===
 ? x = y
returns True or False
 ? z, z * z = x
creates and binds z to the square root of x
===Realis=== 
 $ x = y
introduces x as a new variable equal to y
===Irrealis===
 ` x = y
non-eager evaluation
===Alethic Necessity===
 ^ x = y
x must equal y or an error will result
===Deontic Necessity===
 @ x = y
creates a constraint that whenever either x or y changes then the other changes to match
==Logical Operators==
Not can be freely mixed into statements.
For instance
 not ! x = 3
does not set x to three. And
 not ^ not ( x = y )
means that x can equal y or it can not equal y, it's all good. 
And and Or can also combine statements.
Category:Languages
Category:2017
Category:High-level‏‎
Category:Unimplemented‏‎
Category:Usability unknown‏‎
Magenta

Magenta was created by committee from a proposal thrown out on the Usenet newsgroup alt.folklore.computers in 1995. It was designed to be the most redundant programming language in existence. It has over eighty reserved words, a needlessly convoluted exception system, a threading system that looks entirely too much like a really weird function call syntax, a function call syntax that happens to be really weird, and a curse.
==External resources==
*The Magenta Home Page - The only programming language with a curse 
* 
Category:Unimplemented
Category:Languages
Category:1995
Magic

Magic, created by User:GOMADWarrior in 2013, and still in development, is a language where you summon spirits, objects with a list of instructions, to do your bidding. You summon spirits with spells, the recipe of the spirits. It is also meant to be kind of concurrent, as in executing one instruction per time before jumping to the next spirit.
==Syntax==
In Magic, there are builtin functions, which can return values immediately, and spirits, which must first execute then die to take some values from it. It also uses prefix notation for the builtin functions/statements, and you can use parentheses with them to specify precedence.
You first conjure an empty spell, enchant it, (add instructions to it), then use it as a recipe to summon a spirit, which is a running process.
Spirits have bindings, which are its local variables, and an instruction list. Spells are just an instruction list that isn't running. To pass arguments to spirits when summoning them, you have to use the keyword with. Arguments have to be passed by name, e.g. summon [spiritname] with [varname] [value] and [var2name] [value2] and ...
Spirits loop their instruction list, and only stop when unsummon is called. "unsummon" is usually inside an if statement.
The main program is itself a spirit that loops once, because an automatic "unsummon self" is added at the end of it. If you had a "skip 1" at the end of your program you'd have some problems. Skip skips n instructions, it's useful for making if blocks, if (cond) {n instructions} is done here with:
 if (not cond) skip n
 n instructions ...
 rest of the code
==Examples==
===Fibonacci===
 bind self fib conjure empty
 enchant fib if (= n 0) unsummon self with a
 enchant fib set t b
 enchant fib set b + a b
 enchant fib set a t
 enchant fib set n - n 1
 bind self result summon fib with a 0 and b 1 and n (read)
 print (return result)
===FizzBuzz===
 bindself fizzbuzz conjure empty
 enchant fizzbuzz if (> n 100) unsummon self
 enchant fizzbuzz if (= (% n 15) 0) and (print "FizzBuzz") (skip 3)
 enchant fizzbuzz if (= (% n 5) 0) and (print "Buzz") (skip 2)
 enchant fizzbuzz if (= (% n 3) 0) and (print "Fizz") (skip 1)
 enchant fizzbuzz print n
 enchant fizzbuzz set n + n 1
 summon fizzbuzz with n 1
==External resources==
* Magic interpreter in Lua
* Magic interpreter in Javascript (doesn't have (read))
Category:LanguagesCategory:ImplementedCategory:2013Category:Thematic
Magic The Gathering card deck of programming language

I was thinking... if you could make a deck in Magic: The Gathering to make a program that will run and calculate something, even if you had to make up new cards to do it, then you would write a program by choosing how many of each card to put into the deck.
=Magic: The Esolang=
I've been thinking about this for a while, and here's what I've come up with. The program specifies the number of players, their alliances, and the order of the cards in each deck (which must obey usual deckbuilding rules, except that a deck may end with an infinite amount of basic land). Players play lands, spells, and abilities whenever possible, except that mana abilities are only played when the mana is needed to power a spell or ability. Creatures attack whenever possible and block so as to block all attackers and to block with all creatures if possible, and combat damage is arranged so as to destroy as many enemy creatures as possible, but otherwise there are no constraints (specifically, programs have to be arranged in such a way that the right card is always targeted), except that non-enchanted permanents are enchanted in preference to enchanted ones. Provisionally, output is in the form of revealing cards (outputs their names), and X spells (outputs X), although I'm finding it hard to write program under that output rule.
==Example==
 2 players, P1 v P2. P1 plays first.
 
 P1 decklist:
 Plains x 7
 Forest x 7
 Pacifism x 1
 Oathsworn Giant x 1
 Mountain x 7
 Reflexes x 1
 Phytohydra x 1
 Island x 32
 Mnemonic Nexus x 4
 
 P2 decklist:
 Plains x 7
 Forest x 7
 Pacifism x 1
 Oathsworn Giant x 1
 Mountain x 8
 Phytohydra x 1
 Island x 32
 Mnemonic Nexus x 4
(All the cards here are currently tournament-legal, and the decks are also legal (although not very strong)). The powers of the Phytohydras here form the Fibonacci sequence. I haven't yet been able to make this produce output, however.
== See also ==
* StackFlow
== External resources ==
* A Universal Turing Machine constructed within the Magic: the Gathering rules
Category:Ideas
Magritte

Magritte is a language invented by Marc Hamann, approximately 2005. In Magritte, the only legal program is
 Ceci n'est pas un programme.
Programs in Magritte are very strongly semantically guaranteed never to terminate.
==Implementation==
The following is an implementation in Common Lisp:
 (defun interpret-Magritte (code)
 "Interprets the Magritte CODE, signaling an error upon encountering an
 invalid instruction."
 (declare (type string code))
 (loop
 (unless (string= code "Ceci n'est pas un programme.")
 (error "Invalid program. Expected \"Ceci n'est pas un programme.\""))))
==External resources==
*Lambda the Ultimate comment
*Wikipedia:René Magritte
Category:Joke languages
Category:2005
Category:Unusable for programming
Category:Implemented
Category: Languages
Mail

== Mail ==
Mail, A 2D programming language, with the typical way of having an instruction pointer moving around a grid of characters.
Memory is represented as an array of integers, and you can traverse the array with { and }, left and right respectively.
However, It is easier to use numbers and strings in this language than most other 2D languages, as you are able to use number and string literals just like how you would in any other language.
* "Hello World!" puts the string followed by the number of characters in that string in the memory.
* 256 puts 256 into memory (Now you don't have to multiply single digit numbers.)
=== Example Programs ===
Here are a number of programs that I have written in the language to show its turing completeness and other features.
==== Hello World ====
 "Hello World!" @ ;
* "Hello World!" Puts the characters of Hello World! into memory and the length of those characters
* @ prints the string in order to the console
* ; ends the program.
==== Truth Machine ====
 $,?;>,<
* $ accept one number for input.
* , output as number.
* ? conditional check; skips next instruction if true, doesn't if false.
* ; ends program if wasn't skipped from before
* > set direction of instruction pointer to right
* , output as number
* < set direction of instruction pointer to left
=== Credit ===
Link to Github: Mail
Made By TheJazzCat
Category:Languages Category:Two-dimensional languages Category:Implemented Category:Stack-based
Mailman

This language is about mail; the program runs until all houses have been delivered to. It was created by User:Xanman12321 and User:Andrew3335 in 2019, based on a Google Docs idea.
== Documentation ==
Lines are just paths.
-, /, |, and \: Paths.
<, >, v, and ^: Forks: if this side of the road has any houses with mail to be sent (“deliveries”), go there first. If neither do, stop the program. If both have equally close 
deliveries, choose randomly (CHK)
Houses act like functions.
House 	"Action" 	Equivalent
House A	Recieves mail and puts it in the post office immediately. 	PUSH
House B	Recieves mail, adds a stamp, and gives it back. 	INC
House C	Recieves mail, tears off a stamp, and gives it back. 	DEC
House D	Doesn’t recieve mail, advises you go get some more mail. 	POP
House E	Recieves mail, opens the package. 	OUT
House F	Your own house; go grab a package. 	INP
House G	Slaps the package out of your hands and gives you an empty one.	SET 0
There are also extra symbols.
Symbol	"Action" 	Equivalent
0 	Makes you drop your package; pass by houses without interacting until you get a new one.	Set pointer value to nil, house functions temporarily disabled.
1-9 	Add that number to your package. (or sets it to your package if you have none) 	Adds number to pointer value, sets if value is nil.
M 	The mailman. Starts with an empty package. 	The starting point of the IP..
! 	If you’re holding an empty package, you realize your mistake and move back to the start.	Move to M if 0.
== Examples ==
Print “HI”:
 M99999999E1E
Infinite loop:
 MG!
Truth machine:
[to be programmed]
Category:Languages Category:2019 Category:Thematic
Main Page/Kaksikymmentäneljätuntiaikakausitämänhetkinen

:Back to the Main Page
Kaksikymmentäneljätuntiaikakausitämänhetkinen.ogg Arrrrrgh!
Thanks to the diligent research of our expert team, we have managed to capture a Finn and force him to pronounce this previously-unheard sound. Experts disagree on whether or not this constitutes a demonstration of sentient life in Finland.
Mess of sound kindly ejected from vocal cords by Zwaarddijk of the IRC channel.
Maintain A Dog Through Coding

Maintain A Dog Through Coding (or madtc) is an esoteric programming language made by Fly.
You're a dog owner and your goal is making your dog do things with cookies.
If you run out of cookies, your dog will just stop listening to you, so make sure to give your dog the proper amount of cookies.
You have a particularly smart dog, it's your job to train him.
 Commands
Command	Explanation
woof 	the cookie counter gets incremented by one
bark 	a number is putted on the the stack, then it gets inverted
argh 	it reverses the stack
rrrr 	it outputs the top value of the stack as it's ASCII equivalent
ruff 	it outputs the top value of the stack as a number
barf 	it take a number as an input, then it gets putted on the stack
howl 	the top value duplicates
yawn 	pops the top value of the stack
umph 	it ends the program and checks if the stack is empty, if it's not, it'll run an error
== "Hello World" program==
woof
woof
woof
woof
woof
woof
woof
woof
woof
woof
bark 27
bark 101
bark 801
bark 111
bark 23
bark 78
bark 111
bark 411
bark 801
bark 001
woof
argh
woof
woof
woof
woof
woof
woof
woof
woof
woof
woof
woof
woof
woof
woof
woof
woof
woof
woof
woof
woof
woof
woof
woof
rrrr
yawn
rrrr
yawn
howl
rrrr
rrrr
yawn
yawn
rrrr
yawn
rrrr
yawn
rrrr
yawn
rrrr
yawn
rrrr
yawn
rrrr
yawn
rrrr
yawn
umph
==Implementations==
If you want to try the language you can find it on github
Make me blush

Make me blush is an esoterical language based on the game of "make-me-blush", a foolish game that, sometimes, messes up your instincts and when someone says a certain word, your face gets red and you get the urge to do things not allowed on this wiki. Of course, none of this is based off the personal experience of the creator.
==Commands==
Command 	Description
uwu 	moves the pointer left
rawr 	moves the pointer right
lets date at 	increments pointer
lets kiss at 	decrements pointer
wanna marry? 	asks for input and stores at cell at pointer
you know 	outputs cell at pointer
how bout you? 	toggles ASCII mode (starts in number mode)
your gay because:	BF [
and thats it 	BF ]
==Examples==
===Cat===
A repeating numeric cat program, which terminates on an input of zero (0), constitutes the following:
 lets date at your gay because: wanna marry? you know and thats it
An equivalent founded upon the classical character input and output, perpetuating until a null character is issued, embraces:
 how bout you? wanna marry? your gay because: you know wanna marry? and thats it
===ASCII Loop===
 how bout you? lets date at your gay because: your gay because: you know lets date at and thats it lets date at and thats it
===Truth-machine===
This truth-machine implementation exploits the numeric input/output facilities:
 wanna marry?
 your gay because: you know and thats it
 you know
==Interpreter==
* Common Lisp implementation of the Make me blush programming language.
Category:Turing completeCategory:Brainfuck derivativesCategory:LanguagesCategory:2023Category:Cell-basedCategory:ThematicCategory:Implemented
MalTape

MalTape is a brainfuck derivative created by User:A. Unlike most of the derivatives, it only has 8 bits.
==The tape==
It has 8 bits. The pseudo-commands are the following:
[, ], <,+, and -
===<===
Move the 8-bit tape left a bit.
===+===
Add one. Performs carries on the tape.
Example infinite loop:+<+<+<+<+<+<+<+<+
It loops forever carrying. Note that the leftmost carry maps down to the right end.
===-===
Decrement by 1. Does similar things as +.
===[x===
Jump to x if the left four bits are 0.
===]x===
Jump to x if the right 4 bits are 0.
==Computational class==
It is a BSM, since it can easily compile to the Minsky machine ignoring the limited bits.
==Actual commands==
<: moveRight
+: increment
-: decrement
[: leftMap
]: rightMap
To distinguish commands, you have to capitalize the first letter of the first command, like: incrementDecrement
Category:Languages
Category:Unimplemented
Category:2019
Category:Joke languages
Category:Cell-based
Category:Brainfuck derivatives
Category:No IO
Category:Unusable for programming
Malbolge20

Malbolge20 is an extension to the programming language Malbolge that expands the word sizes to 20 trits, thus allowing to write programs of up to ~3.4 Gb.
==See also==
* Malbolge
* Malbolge Unshackled
==External resources==
* Online interpreter and C source, low-level and high-level assembler
Category:Languages
Category:2013