nyuuzyou/wikis huggingface dataset:
Merucik

Merucik is a Brainfuck derivative made by User:Conor O'Brien that adds some minor functionality to aid the programmer in coding. Merucik programs operator on a right-open, theoretically-unbound tape. Each cell can contain an arbitrary number.
== Instructions ==
Merucik contains all the commands found in Brainfuck, and features the following added commands:
Command 	Operation
" 	Begins string parsing. Will write ASCII characters to the strip until another " is met. Uses ^ as an escape character.
: 	Outputs the current cell's value as a number
; 	Takes numeric input
~ 	Copies the current cell's value to the register (a single-celled container separate from the strip.)
# 	Writes the value from the register to the current cell.
N 	Writes a linefeed to the current byte and increments pointer.
S 	Adds 32 to the current byte.
F<name>{...}	Defines a function <name> that executes ... upon being called. (<name> can be empty.)
f<name>{N} 	Calls function <name> N (or one) times.
(...) 	Ignores ... (comment).
\ 	Terminate program
+*% 	Performs (current cell value) OP (previous cell value), setting the result to the register.
/ 	Sets the current cell's value to 1/(current cell's value)
- 	Sets the current cell's value to -(current cell's value)
== Example Programs ==
=== Hello, World! (1) ===
"Hello, World!"[.<]
=== Hello, World! (2) ===
This can probably be simplified more, but here is one using functions.
F{++++++++++++}++++++++SS.S++.>f{}..+++.~>Sf{}.>S.SSf{2}-.#.+++.------.>SSf{3}.>S+.
F{++++++++++++} (+12)
++++++++SS. (H)
S++. (e)
>f{}.. (ll)
+++.~ (o; store to register)
>Sf{}. (right and ,)
>S. (right and )
SSf{2}-. (w)
#. (o)
+++. (r)
------. (l)
>SSf{3}. (d)
>S+. (!)
== Computational Class ==
Merucik is Turing-complete by a trivial reduction to Brainfuck.
Category:Languages
Category:Brainfuck_derivatives
Category:Cell-based
Category:Turing complete
Category:Unimplemented
Messyscript

==Messyscript==
Messyscript is a very hard-to-read Trivial Brainfuck Substitution.
==Syntax==
 20ri-4;t[5;t'[y;e'teu;354y;;56;'5lu;y65l'ytyl';ry;rtly;t'yl'r;y' : Increment to the pointer
 ];ae][flw[er.[w;r';ew.'rt;e';,erf/r;t.e'.fre.f'r;.rg;el[rw][p43p3 : Decremet to the pointer
 930pl[wer;lr[p[lwetl[erwltrewt[er;t3l.t;43.';w]er\e]e;g[er.][.rt[.e[w]r[ : move the pointer left
 \];[]lr[plp[r[pelpr[,gp[lsp[glr[pt,g[pr,g[lsg[plfsdgdsfpl[erlt[lwt[43[]5l4[;.tr. : move the pointer right
 ][][e[w]prepf][eg]rpe[t]lre[]lgr]o320wr89`]2l1]p`l23pr2o4]2lf]2;r][32;r][2``]234;][23 : print the pointer as a char
 ]\]p][l[weo[p4o40ti40er0iteotp[r]23;[rle[wptlo34wtp[rel[1;`][l3[l[rplew[fl[`1[l[wlr[pewlr[p : input a char to the pointer
 \];[]fl[roeotp[ore][gper][g;rw][;g][r;eg][le]f[el]f]w[r][wper][pwtlregl]erl][;]e;][e;t[erpt][p : start a Brainfuck loop
 \[]pe[3202-432o-0rkepk[1[pwplwpflerp[glep[r[er[pe[tpre][]t\][p[0-=30-323-=232[r[ept[erg[erpt] : end a Brainfuck loop
==Example==
Hello,world
 20ri-4;t[5;t'[y;e'teu;354y;;56;'5lu;y65l'ytyl';ry;rtly;t'yl'r;y'\];[]fl[roeotp[ore][gper][g;rw][;g][r;eg][le]f[el]f]w[r]\];[]lr[plp[r[pelpr[,gp[lsp[glr[pt,g[pr,g[lsg[plfsdgdsfpl[erlt[lwt[43[]5l4[;.tr.[wper][pwtlregl]erl][;]e;][e;t[erpt][p];ae][flw[er[w;r';ew.'rt;e';,erf/r;t.e'.fre.f'r;.rg;el[rw][p43p3];ae][flw[er.[w;r';ew.'rt;e';,erf/r;t.e'.fre.f'r;.rg;el[rw][p43p3];ae][flw[er.[w;r';ew.'rt;e';,erf/r;t.e'.fre.f'r;.rg;el[rw][p43p3
It is too long to show here.
Category:Brainfuck equivalents Category:Languages
Meta-categorial

Meta-categorial is an esolang made by User:Heav in 2022. It exists.
== Language overview ==
When the esolang wiki page for this esolang has its categories set, the language is to change.
It should change in computational class, dimensionality, paradigm, implementation status and brainfuck derivative status each time.
That being said, the language works as follows.
=== How it works ===
A program consists of arbitrary actors. An actor consists of a set of coordinates and an infinite tape of integers, with values initialized to 0.
All actors have the same program.
A program is a list of instructions, which can have arguments.
Arguments can be integers or relative references to the tape. notated here as ^(number). ^0 refers to the current selected cell, for example.
There is an actor at 0, 0.
 + x y: Add x and y, store in tape.
 - x y: Subtract.
 * x y: Multiply.
 / x y: Integer divide.
 % x y: Modulo.
 i: Take an ascii input, store in tape.
 o x: Ascii output.
 p x: Blocking write to any adjacent actor.
 g: Blocking read from any adjacent actor.
 m x y: Move relatively. Actors may overlap.
 x: Terminate this actor.
 c x y z: Create a new actor at relative x, y, starting from instruction z.
 ^ x: Advance the tape x spaces.
Category:Languages Category:2022
Meta-meta-meta-meta-meta

== layers ==
=== layer 1 ===
 state * alive
 become dead on 4 alive
 become dead on 7 dead
 state dead
 become alive on 3 alive and 5 dead
=== layer 2 ===
 s turns to state
 b turns to become
 o turns to on
 a turns to and
=== layer 3 ===
 before is
 middle is turns to
 after is
=== layer 4 ===
 b turns to before
 m turns to middle
 a turns to after
 i turns to is
=== layer 5 ===
 before is
 middle is turns to
 after is
Category:Joke_languagesCategory:2024Category:Languages
MetaGlow

MetaGlow is a programming language. And it consists mostly of If-Else statements. All
of the code is executed in a loop and all the states are saved.
== Syntax ==
== Hello, World! ==
 SYSTEM - INACTIVE ?
 : [ SYSTEM - ACTIVE ! ]
 ; [ SYSTEM - INACTIVE ! ]
 
 ACCESS - STDIO ?
 : [ ACCESS - STDIO ! ]
 ; [ CODE - 1 !
 SYSTEM - INACTIVE ! ]
 
 WRITE - AVALIABLE ?
 : [ WRITE - "Hello, World!" ! ]
 ; [ CODE - 1 ! 
 SYSTEM - INACTIVE ! ]
== Cat ==
 SYSTEM - INACTIVE ?
 : [ SYSTEM - ACTIVE ! ]
 ; [ SYSTEM - INACTIVE ! ]
 
 ACCESS - STDIO ?
 : [ ACCESS - STDIO ! ]
 ; [ CODE - 1 !
 SYSTEM - INACTIVE ! ]
 
 
 READ - AVALIABLE ?
 : [ WRITE - AVALIABLE ?
 : [ READ - INPUT_TEXT !
 WRITE - INPUT_TEXT ! ]
 ; [ CODE - 1 !
 SYSTEM - INACTIVE ! ]
 ; [ CODE - 1 !
 SYSTEM - INACTIVE ! ]
== Implementations ==
Currently working on C++ implementation.
Category:Languages Category:2019
MetaGolfScript

MetaGolfScript is a family of programming languages, designed to allow zero length programs to be written, in order to win code-golf contests (although this sort of technique for winning contests has been banned at at least one code-golf site,https://codegolf.meta.stackexchange.com/a/5076/117478 and many others don't allow the use of arbitrary languages).
== Overview ==
The family consists of multiple languages, all named MetaGolfScript-N, where N is any integer.
For every task which can be solved with GolfScript:
# All languages in the family can solve the task as well
# There exists a language in the family, in which a zero length program solves the task.
== Syntax ==
A non-empty MetaGolfScript-N program behaves identically to the same program in GolfScript, regardless of N.
An empty MetaGolfScript-N program behaves identically to the Nth possible GolfScript program. Programs are enumerated first by size, then by lexicographic order. E.g. program 0 is empty, program 1 contains a single NUL character, and so forth.
== Examples ==
 'Hello, World!'
Prints "Hello, World!" in all MetaGolfScript-N languages.
The empty program prints "Hello, World!" in the MetaGolfScript-209180605381204854470575573749277224 language.
== Computational class ==
All MetaGolfScript languages are Turing-complete, as it can be shown to be computationally equivalent to GolfScript: any non-empty MetaGolfScript langauage behaves identically to the same program in GolfScript.
== The interpreter ==
The following Python script implements MetaGolfScript-N, based on an existing GolfScript interpreter.
The interpreter should be saved in a file named metags.N.py, to interpret the MetaGolfScript-N language.
 import sys, os, tempfile
 gs="./golfscript.rb"
 def ns(n):
 	l=0
 	while n>=256**l:
 		n-=256**l
 		l+=1
 	return "".join(chr(n/(256**i)%256) for i in range(l-1,-1,-1))
 p = sys.argv[1]
 if os.stat(p).st_size == 0:
 	tmp = tempfile.NamedTemporaryFile()
 	tmp.write(ns(long(sys.argv[0].split('.')[-2])))		# Script name = meta-gs.N.py
 	tmp.flush()
 	p = tmp.name
 os.system("%s %s"% (gs, p))
==See also==
* Ultimate Golfing Simulator 3000
Category:Languages
Category:Golfing language
Category:Meta-languages
Meta Turing-complete

A language can be said to be meta Turing-complete if it is able to describe a Turing-complete language.
== Meta Turing-completeness vs Turing-completeness ==
It is possible to make the argument that, because all meta Turing-complete languages are able to describe (implement or compile) a Turing-complete language, they are also Turing-complete. However, a meta Turing-complete language does not necessarily allow an arbitrary effect at an arbitrary point. They simply need to be able to describe a Turing-complete language, which does not imply that they are able to control their input, or able to execute commands independently. If a meta Turing-complete language is combined with some input, it is a Turing-complete language.
A Turing-complete language is necessarily meta Turing-complete: it is able to interpret (describe) another Turing-complete language.
== Input/Output ==
While meta-languages sometimes have input/output (the code to compile/the compiled code or the code to interpret/the interpreted code), it is not necessary for meta Turing-completeness; like Turing-completeness, the definition of meta Turing-completeness does not prevent anyone from setting up a starting memory-area and/or reading from the finished memory.
== The physical world ==
It is not possible to implement a meta Turing-complete language in the real world, because it would require an implementation of a Turing-complete language, which is impossible.
== Relationship to esoteric programming ==
Some of the esoteric languages are meta-languages; they describe other languages. If those languages are able to describe a Turing-complete language, they are meta Turing-complete. An example of a meta Turing-complete language is ALPACA: it is able to describe Conway's Game of Life, which is a Turing-complete cellular automaton.
Category:Concepts
Metafractran

Metafractran is a derivative of Fractran created by User:Challenger5 in which all program files are irrelevant. Rather than being specified by a program file, code is instead determined from that file's metadata; specifically, its location in the filesystem.
* The list of fractions is given by the longest suffix of the list of components of the filepath of the form <positive integer>:<positive integer>.
* The name of the file must consist of a single positive integer, representing the starting number, followed by an optional file extension.
The file passed to the interpreter must exist, but no restrictions are otherwise made on its contents.
== See Also ==
* Fractran
* Folders
== External Links ==
* Interpreter in Python
Category:Languages
Category:2018
Category:Implemented
Metat

Metat is an interpretered meta programming language. It's main goal is to act as an interpreter or parser itself.
== Syntax ==
The Metat program is a parser in itself, so it has to load a source file.
It will run through the source file character by character.
The program is segmented into the initialization segment, and the rule segment.
In the initialization segment you will declare states, registers and allocate memory.
state myState declares a state that the parser can be in.
register n type defined a numbered register n with the specified type type. There can be a total of 16 registers, ranging from 0 - 15.
Valid types are: char string uint8 uint16 uint32 int8 int16 int32 int uint 
alloc amount regx allocates the specified amount of bytes and binds them to the register regx
Registers are referenced as regx where x is the number of the register. 
== Examples ==
A Brainfuck interpreter.
 ::A Brainfuck interpreter written in metat.
 state top
 state fast
 state re
 register 0 uint8
 register 1 uint16
 register 2 uint8
 register 3 int16
 start
 	alloc 65535 reg0
 case top
 	on +
 		take reg0 reg1 reg2
 		add reg2 1
 		put reg2 reg0 reg1
 	on -
 		take reg0 reg1 reg2
 		sub reg2 1
 		put reg2 reg0 reg1
 	on <
 		sub reg1 1
 	on >
 		add reg1 1
 	on [
 		take reg0 reg1 reg2
 		eql 0
 		if
 			then fast
 	on ]
 		take reg0 reg1 reg2
 		eql 0
 		if
 			then re
 	on .
 		take reg0 reg1 reg2
 		print char reg2
 	on ,
 		get char reg2
 		put reg2 reg0 reg1
 case fast
 	start
 		set reg3 0
 	on [
 		add reg3 1
 	on ]
 		sub reg3 1
 		eql reg3 0 reg2
 		if
 			then top
 		less reg3 0 reg2
 		if
 			error Unbalanced brackets
 	eof
 		error Unbalanced brackets
 case re
 	start
 		set reg3 0
 	on [
 		add reg3 1
 		rewind 2
 	on ]
 		sub reg3 1
 		eql reg3 0 req2
 		if
 			then top
 		less reg3 0 reg2
 		if
 			error Unbalanced brackets
 		rewind 2
 	eof
 		error Unbalanced brackets
Category:Languages Category:Meta-languages
Methesis

Methesis is a programming language designed by User:Fr34k in 2010.
== Introduction ==
Methesis is a language based on passing arguments to functions. There are no ways of defining custom functions, due to the nature of the language. Every method that exist is native and always returns a value (except main() and output()).
== Examples ==
Hello, World! program
 main(output(string(“Hello, World!”)))
Since Methesis ignores white-space, the above program is equivalent to
 main(
 output(
 string(“Hello, World!”)
 )
 )
Until the author gets the time to write a full article, an introduction, language explanation and language reference can be found in the document listed below.
== External resources ==
* Methesis Overview 
Category:2010
Category:Languages
Methionyl­threonyl­threonyl­glutaminyl­alanyl­prolyl­threonyl­phenylalanyl­threonyl­glutaminyl­prolyl­leucyl­glutaminyl­seryl­valyl­valyl­valyl­leucyl­glutamyl­glycyl­seryl­threonyl­alanyl­threonyl­phenylalanyl­glutamyl­alanyl­h

#REDIRECT Titin
Metropolis

Metropolis is a 2D Turing Machine language designed by Brian Thompson in 2006. It was originally inspired by Langton's Ants, but later refined on the more general idea of Turmites (also called Turning Machines) - the two-dimensional equivalent of Turing Machines.
==Syntax==
A Metropolis program operates by specifying a symbol transition table that tells Metropolis how to interpret the symbols at each grid cell. Each symbol may be any printable ASCII character, and the rules specify both which direction the program should turn, and what symbol should replace the current symbol. An example to implement Langton's Ant is given here:
 S0 RS Dir WS S1
 0 ' ' L * 0
 0 * R ' ' 0
In this table, S0 and S1 stand for State0 and State1 - the state of the program when it encounters the symbol, and the state when it leaves the symbol. Langton's Ant does not utilize any states, so they are left as 0 for now. RS is called the Read Symbol, and WS is the Write Symbol - which identify initial and final symbol values for each cell. The Dir column signifies which direction to turn when leaving the cell. For Langton's Ant, when it encounters a space it changes it to an * and turns left, while when it encounters a * it unmarks it and turns right. Any characters not specified by the rules table, including spaces, have an implicit "Do nothing" transition, which makes the program continue straight past the cell without changing the symbol or the state. The following is the actual syntax used in Metropolis:
 {S0,S1}[RS,WS,Dir]
States can be any string that does not include [,],{,},%,spaces, or commas. Symbols may be ANY single printable ASCII character. - including spaces. Lastly, the direction may be L, R, S (straight), or B (backwards). Allowances may be made in the final implementation for 45-degree angles as well.
==Non-determinism==
To add non-determinism to the language, multiple transition rules for the same symbol can appear. Each one may be proceeded by a % sign and a positive integer which identifies the weighting of the transition.
 {S0,S1}[RS,WS,Dir]%Weight
==Computational Class==
Metropolis is Turing complete, since it can simulate any ordinary Turing machine with 95 symbols or less by travelling along a single line: Split each state into two versions according to which direction the machine is moving in, and use S and B directions as appropriate.
==External resources==
* Turmite article on MathWorld
* Turmite article on Wikipedia
* Metropolis implementation on Github 
Category:Languages
Category:2006
Category:Turing complete
Category:No IO
Category:Two-dimensional languages
Category:Implemented
MewMew

MewMew is an Esoteric programming language which let's one program in cats' language. MewMew is created by Palash Bauri and first released on July , 2020. The language has no concept of formal numbers in it instead it uses mews
== Language Overview ==
MewMew does not use formal numbers instead it uses one to multiple mew(s). mew is converted to 1 , mewmew is converted to 2 and similarly mewmewmewmewmewmewmewmewmewmew is converted to 10.
== Examples ==
==== Hello World ====
 ::$####(mew) * mewmewmewmewmewmewmew + mewmew , ####(mew) * mewmewmewmewmewmewmew - mew , ####(mew) * mewmewmewmewmewmewmew + mewmewmewmewmewmew , ####(mew) * mewmewmewmewmewmewmew + mewmewmewmewmewmew , ####(mew) * mewmewmewmewmewmewmewmew - mew , mewmewmewmewmewmewmewmewmewmewmewmewmewmewmewmew * mewmew , ####(mew) * mewmewmewmewmewmewmewmewmew - mewmewmew , ####(mew) * mewmewmewmewmewmewmewmew - mew , ####(mew) * mewmewmewmewmewmewmewmew + mewmew , ####(mew) * mewmewmewmewmewmewmew + mewmewmewmewmewmew , ####(mew) * mewmewmewmewmewmewmew - mewmew;
==== Addition of 2 and 3 ====
 m = mewmew + mewmewmew;
 ::m;
==== Print All Numbers Divisible by 2 under 100 ====
 m = mew;
 @#####(mew):
 m % mewmew == mew - mew ? ::m;;
 m = m+mew;
 ;
==== Factorial (of 5) ====
 m = mewmewmewmewmew;
 m_ = mew;
 @m:
 m_ = m_ * m;
 m = m - mew;
 ;
 ::m_; 
==== Reading From Stdin ====
 m << ;
 ::m ** m;
== Source Code & Documentation ==
* GitHub : https://github.com/bauripalash/mewmew
MiLambda

MiLambda(μλ), is esoteric two dimensional turing-complete programming language.
In this languages all instructions are letters of Greek alphabet.
== Operands ==
===Direction control instructions===
> Set the direction to right
< Set the direction to left
^ Set the direction to up
v Set the direction to down
Ι Redirect the control flow
ι Redirect the control flow
===Сonditional direction control instructions===
Z If the cell is not 0, reverse the control flow. (It bounces off the Z)
ζ If the cell is 0, reverse the control flow. (It bounces off the ζ)
| Reverse the control flow if coming from a right/left-direction
_ Reverse the control flow if coming from a up/down-direction
Υ If store is not equals 0 change direction to left
υ If store is not equals 0 change direction to right
σ If cell is not equals store change direction to up
Σ if cell is not equals store change direction to down
===Cell/store control instructions===
Δ Increment the cell
δ Decrement the cell
E Adding 10 to current cell value
ε Deleting 10 from value of current cell
ς Set current cell value to 0
Ξ store = cell
ξ cell = store
s memory[cell] = store
g store = memory[cell]
P memory[store] = cell
ρ cell = memory[store]
` Decrement the store
' Increment the store
===I/O instructions===
Θ Output the cell as character
θ Output the cell as number
π Read character from input
===Special instructions===
λ halt the program
== Examples ==
=== Hello world ===
> EEEEEEEΔΔΘς v
v ςΘΔEEEEEEEEEE <
> EEEEEEEEEEEδδΘς v
v ΘδδEEEEEEEEEEEς <
> ς EEEEEEEEEEEΔΘ v
v ΘΔΔΔΔEEEEς <
> ςEEEΔΔΘ v
v ΘδEEEEEEEEEEEEς <
> ςEEEEEEEEEEEΔΘ v
v ΘΔΔΔΔEEEEEEEEEEEς <
> ςEEEEEEEEEEEδδΘ v
v ΘEEEEEEEEEEς <
> ςEEEΔΔΔΘ λ
=== Count to five ===
>Δθ Σ λ
 ^ <
== External resources ==
* http://alc.comuf.com/milambda.php (First online interpretater)
Category:Languages
Category:2015
Category:Two-dimensional languages
Category:Cell-based
Category:Turing complete
Category:Implemented
Mic

Mic is a stack-based esoteric programming language created by User:D, loosely based on the concept of primitive recursive functions.
== Data Structures ==
The primary data structure is a numeric stack, but there's also an "accumulator" (which is actually a stack of lists).
A demonstration of the A stack:
| [5] | <-- TOS
|[1,2,3,4,5]|
| [1,2,3] |
== Commands ==
=== Numeric commands ===
* 123: Push the number onto the stack.
* s: Increment TOS.
=== "Accumulator" commands ===
* @: Pop x. Pops x values from the stack. Push this list onto A.
* A: Retrieve TOS of A. Dump this list onto the stack.
* ;: Drop the TOS of A.
* k: Pops x. Push the x-th item of the TOS of A.
=== Looping Commands ===
* I: Push positive infinity. Notes:
:* Inf() - 1 is still Inf().
:* No natural number can equal Inf().
* (...): "Mic" loop. Pop x:
:* For each integer i in the range [0 .. x-1]:
::* Push i.
::* Execute ... as Mic code.
::* Pop t. If t == 0: Exit the loop.
:* Push the last assigned value of i.
== Primitive recursive operators in Mic ==
In the following implementations, we use [g] to represent the body of the function g (a sequence of stack commands).
=== Composition ===
Here's a demonstration with 3 arguments (replace the bracket-enclosed commands with your actual commands):
Stack: 1 2 3
3@ A [h1] A [h2] [g] ;
=== Primitive Recursion ===
For simplicity purposes, we'll do this instead:
P(g,h)(0, ...a) = g(...a)
P(g,h)(n, ...a) = h(n-1, P(g,h)(n-1, ...a), ...a)
Say, we have the following items on the stack:
n a1 a2 ... ai
We'll use {i} to represent the constant value of i.
For the base case, we simply call g on a1 ... ai.
{i}@A [g]
Now, before we enter the recursive case, we update the accumulator to prepend it with our g value.
A;{i}s@
Here's the recursive case (with n as the argument to the "Mic" loop):
(A [h] 2k 3k ... {i}sk ; {i}s @ 1)
(Where the ... represents an enough number of k commands to push all arguments except for the first)
Drop the number returned by the "Mic" loop:
1@;
Finally, we push the first item of the final value of the accumulator (which is our application result):
1k ;
The full program, again:
{i}@A [g] A;{i}s@ (A [h] 2k 3k ... {i}sk ; {i}s @ 1) 1@; 1k ;
=== Minimization ===
I([g])
== Examples ==
=== Predecessor ===
(s)
== External Links ==
* Reference Implementation (Python)
Category:2023
Category:Languages
Category:Stack-based
Category:Implemented
Microscript II

Microscript II is a successor to Microscript, designed by SuperJedi224. It features dynamic typing, memory state saving, and code block literals, among other new features.
As Microscript, Microscript II has two variables, but has 3 primary stacks as opposed to the original 2 and adds a special Continuation stack.
==Specs and Implementation==
https://github.com/SuperJedi224/Microscript-II
==Computational Class==
Microscript II is turing complete by equivalence to Brainf***. See Microscript for more information.
==Example Programs==
===Infinite Loop===
 1[
===Square Root of Input===
 F@
===Square of Input===
 Fs*
===Quine===
 "q"q
===Truth Machine===
 N[p
===Hello, World!===
 "Hello, World!"
===Roll 1048576d4===
 20e_ss{4R+s}*
Category:Golfing languageCategory:LanguagesCategory:ImplementedCategory:2015