nyuuzyou/wikis huggingface dataset:
M==

m== is an esoteric programming language by User:A inspired by This=That. This programming language tries to represent 6 conditional operators using only 1 operator.
==Syntax==
& "this is a comment" 	The & operator takes a string and ignores it. It works like a comment.
= 	Set a variable to a value.
print 	Output a variable.
input 	Set the variable "input" as input.
+, -, *, and / 	Do math, like 
x=4
Jerome=x-2
sets x as value 4 and Jerome as value 2 (4-2). Also: 
fruit="fly"
printer="paper"
sticky=fruit+printer
sets fruit as value fly, printer as value paper, and sticky as value flypaper (word math only works with plus).
Note that if you try to do math on strings using -, *, or /, the strings will be converted to its hash value.
if exp {things_to_do} 	execute "things_to_do" if exp is true.
while exp {things_to_do}	execute "things_to_do" until exp is false.
===Conditions===
Conditions support only one operator, which is the m== operator.
& "m== a b c"
& "evaluate the maximum value of a and b. Return true if the value is equal to c. Otherwise, return false."
& "Works like:"
if m== 12 13 13
{
 a="success"
 print a
}
How to implement other conditionals in if statements:
& "a==b"
if m== a b a
{
 if m== a b b
 {
 & "a==b"
 }
}
& "a!=b"
flag=true
if m== a b a
{
 if m== a b b
 {
 flag=false
 }
}
if m== flag true flag
{
 if m== flag true true
 {
 & "a!=b"
 }
}
& "a>b"
if m== a b a
{
 & "a>b"
}
& "a
& "a>=b"
flag=true
if m== a b a
{
 flag=false
}
if m== flag true flag
{
 if m== flag true true
 {
 & "a>=b"
 }
}
& "a<=b"
flag=true
if m== a b a
{
 flag=false
}
if m== flag true flag
{
 if m== flag true true
 {
 & "a<=b"
 }
}
==Computational Class==
You can translate This=That programs easily into this programming language, so it is Turing-complete.
Category:Languages
Category:2019
Category:Unimplemented
Category:Turing complete
M?!

M?! is an esoteric programming language based on Brainfuck but with less commands:
==Commands==
Command	Use
m 	Goes to the next mode (0>1>2>3>0)
? 	Mode 0: increment the current cell.
Mode 1: Moves the pointer right.
Mode 2: Starts a while loop.
Mode 3: Outputs the current cell as an ascii character.
! 	Mode 0: decrement the current cell.
Mode 1: Moves the pointer left. 
Mode 2: Ends a while loop.
Mode 3: Inputs into current cell the ascii code of a character character.
==Turing-completeness==
Because by just changing the mode you can get a equivalent to all BF commands, it is Turing-complete.
==Examples==
The following M?! code prints the message “Hello World!” to the standard output:
 ????????mm?mmm?mmm????mm?mmm?mmm??m?mmm???m?mmm???m?mmm?m!!!!mmm!mm!mmm?mmm?m?mmm?m?mmm!m??mmm?mm?mmm!m!mmm!mmm!mm!mmm??mm?mm?mmm!!!mmm?m???????mmm??m???mmm?mm??mm?mm!mmm!mmm?mm!mm?m???mmm?m!!!!!!mmm?m!!!!!!!!mmm?mm??mmm?mmm?mm?mmm??mmm?
==External resources==
* GitHub Implementation of the M?! programming language in Common Lisp.
Category:Languages
Category:2019
Category:Cell-based
Category:Turing complete
Category:Turning tarpits
Category:Brainfuck equivalents
Category:Implemented
Category:Low-level
MASL

Matto's Assembly-Styled Languagehttps://github.com/Matto58/masl is an interpreted esoteric programming language that looks like assembly but really isn't assembly. It was made by Matto. The first version (v1.0.0-beta1) was released on August 5th 2022 and the latest version (v1.0.0-beta6.1) was released on September 1st 2022. The language is still in beta development. There have been a total of 8 releases and pre-releases.
= Changeloghttps://github.com/Matto58/masl/releases =
:This is a stripped down version of the changelog available here.
== v1.0.0-beta1 ==
* Initial release.
== v1.0.0-beta2 ==
* Fixed commands jmp and jmr
* Added command cnl
== v1.0.0-beta3 ==
* Fixed jmp and jmr commands
* New argument: -sc / --show-current
== v1.0.0-beta4 ==
* New commands: rng, flr, frl, flw
* New argument: -ri / --remove-intro
* New feature: intro!
== v1.0.0-beta4.1 ==
* Fixed jmp, jmr
== v1.0.0-beta5 ==
* Commands cnt and cnl have been updated to have customizable colors!
* Errors are now red!
* Lines displayed with -vl / --view-lines are now gray!
* The intro is colorful!
* New arguments: -mc / --monochrome, -h / --help!
== v1.0.0-beta6 ==
* Bang operations!
:* The ability to run stuff without putting them in a file!
:* Use * to pass multiple arguments!
* Code arguments!
:* Pass with -a or --pass-arg!
:* Separate arguments with :!
* Arrow references!
:* Get values from registers and use them as arguments!
::* Like this: >(bank):(register)
:* Works with cnt and cnl for now.
* New arguments:
:* --show-warns / -sw
:* --show-args / -sa
:* --pass-arg / -a
== v1.0.0-beta6.1 ==
* Fixed jmp command
= Example code =
== Hello Worldhttps://github.com/Matto58/masl/wiki/Examples#hello-world ==
 
 # Hello World in MASL v1.0.0
 psh 0,0,0x48
 psh 0,1,0x65
 psh 0,2,0x6c
 psh 0,3,0x6f
 
 psh 1,0,0x57
 psh 1,1,0x72
 psh 1,2,0x64
 
 psh 2,0,0x2c
 psh 2,1,0x21
 
 cnt 0,0,ch
 cnt 0,1,ch
 cnt 0,2,ch
 cnt 0,2,ch
 cnt 0,3,ch
 
 cnt 2,0,ch
 cnt 3,3,ch
 
 cnt 1,0,ch
 cnt 0,3,ch
 cnt 1,1,ch
 cnt 0,2,ch
 cnt 1,2,ch
 
 cnt 2,1,ch
 
Output:
 Hello, World!
== For loophttps://github.com/Matto58/masl/wiki/Examples#for-loop-1-9 ==
 
 # For loop in MASL v1.0.0
 psh 0,0,0
 psh 0,1,1
 psh 0,2,9
 adr 0,0,0,0,0,1
 cnt 0,0,nm
 jmr 4,0,0,0,2,<
 
Output:
 123456789
== Fibonacci sequencehttps://github.com/Matto58/masl/wiki/Examples#fibonacci-sequence ==
 
 # Fibonacci sequence in MASL v1.0.0
 # Gets the nth number in the fibonacci sequence
 # n = bank 0, register 0
 psh 0,0,100
 psh 3,3,0
 psh 3,2,1
 psh 1,0,0
 psh 1,1,1
 psh 1,2,0
 adr 1,2,1,0,1,1
 adr 1,0,1,1,3,3
 adr 1,1,1,2,3,3
 sbr 0,0,0,0,3,2
 jmr 10,0,0,3,3,>
 cnt 1,0,nm
 
Output:
 354224848179262000000
Category:Languages Category:Implemented Category:2022
MASM/Bitwise and

:
==globals.masm==
 nine ptr-size
 arg
 arg1
 ret
 old-ipt
==and.masm==
 lab and
 cmt ret = not(nand(arg, arg1))
 alc one
 get arg
 nnd arg1
 nnd vpt
 set ret
 
 cmt set ipt to old-ipt + 9 to skip function call
 alc nine
 set tmp
 adr old-ipt
 get nine
 drf vpt
 fre tmp
 set ipt
==main.masm==
 and
 loop
 tmp
 two
 new-out
 
 lab loop
 cmt call loop
 alc ptr-size
 set tmp
 adr loop
 drf vpt
 fre tmp
 set ipt
 
 lab main
 cmt init nine/ptr-size
 alc one
 get one
 rot one
 rot one
 rot one
 rot one
 rot one
 nnd vpt
 set tmp
 alc one
 get one
 nnd vpt
 nnd tmp
 fre tmp
 set nine
 
 cmt copies 0th byte of in to arg
 alc one
 get in
 set arg
 
 cmt copies 1st byte of in to arg1
 alc ptr-size
 set tmp
 adr in
 get one
 drf vpt
 fre tmp
 set tmp
 alc one
 get tmp
 set arg1
 
 cmt set old-ipt
 alc ptr-size
 set tmp
 adr ipt
 drf vpt
 fre tmp
 set old-ipt
 
 cmt call and
 alc ptr-size
 set tmp
 adr and
 drf vpt
 fre tmp
 set ipt
 
 cmt init two
 alc one
 get one
 rot one
 rot one
 rot one
 rot one
 rot one
 rot one
 rot one
 set two
 
 cmt alloc new-out and sets 0th byte to ret from and
 alc two
 get ret
 set new-out
 
 cmt null terminates new-out
 alc ptr-size
 set tmp
 adr new-out
 get one
 drf vpt
 fre tmp
 cmt abusing the fact that out is currently 0
 get out
 
 cmt out = new-out
 alc ptr-size
 set tmp
 adr new-out
 drf vpt
 fre tmp
 set out
 
 cmt clean-up (in case we want to add more code)
 fre arg
 fre arg1
 fre ret
 fre two
 
 cmt call loop
 alc ptr-size
 set tmp
 adr loop
 drf vpt
 fre tmp
 set ipt
Category:Examples
MASM/Bitwise nor

:
==globals.masm==
 nine ptr-size
 arg
 arg1
 ret
 old-ipt
==nor.masm==
 tmp
 
 lab nor
 cmt tmp = not(arg)
 alc one
 get arg
 nnd vpt
 set tmp
 
 cmt ret = not(nand(not(arg1), tmp)) = not(or(arg1, arg)) = nor(arg, arg1)
 alc one
 get arg1
 nnd vpt
 nnd tmp
 fre tmp
 nnd vpt
 set ret
 
 cmt set ipt to old-ipt + 9 to skip function call
 alc nine
 set tmp
 adr old-ipt
 get nine
 drf vpt
 fre tmp
 set ipt
==main.masm==
 nor
 loop
 tmp
 two
 new-out
 
 lab loop
 cmt call loop
 alc ptr-size
 set tmp
 adr loop
 drf vpt
 fre tmp
 set ipt
 
 lab main
 cmt init nine/ptr-size
 alc one
 get one
 rot one
 rot one
 rot one
 rot one
 rot one
 nnd vpt
 set tmp
 alc one
 get one
 nnd vpt
 nnd tmp
 fre tmp
 set nine
 
 cmt copies 0th byte of in to arg
 alc one
 get in
 set arg
 
 cmt copies 1st byte of in to arg1
 alc ptr-size
 set tmp
 adr in
 get one
 drf vpt
 fre tmp
 set tmp
 alc one
 get tmp
 set arg1
 
 cmt set old-ipt
 alc ptr-size
 set tmp
 adr ipt
 drf vpt
 fre tmp
 set old-ipt
 
 cmt call nor
 alc ptr-size
 set tmp
 adr nor
 drf vpt
 fre tmp
 set ipt
 
 cmt init two
 alc one
 get one
 rot one
 rot one
 rot one
 rot one
 rot one
 rot one
 rot one
 set two
 
 cmt alloc new-out and sets 0th byte to ret from nor
 alc two
 get ret
 set new-out
 
 cmt null terminates new-out
 alc ptr-size
 set tmp
 adr new-out
 get one
 drf vpt
 fre tmp
 cmt abusing the fact that out is currently 0
 get out
 
 cmt out = new-out
 alc ptr-size
 set tmp
 adr new-out
 drf vpt
 fre tmp
 set out
 
 cmt clean-up (in case we want to add more code)
 fre arg
 fre arg1
 fre ret
 fre two
 
 cmt call loop
 alc ptr-size
 set tmp
 adr loop
 drf vpt
 fre tmp
 set ipt
Category:Examples
MASM/Bitwise not

:
==globals.masm==
 nine ptr-size
 arg
 ret
 old-ipt
==not.masm==
 tmp
 
 lab not
 cmt ret = nand(arg, arg) = not(arg)
 alc one
 get arg
 nnd vpt
 set ret
 
 cmt set ipt to old-ipt + 9 to skip function call
 alc nine
 set tmp
 adr old-ipt
 get nine
 drf vpt
 fre tmp
 set ipt
==main.masm==
 not
 loop
 tmp
 two
 new-out
 
 lab loop
 cmt call loop
 alc ptr-size
 set tmp
 adr loop
 drf vpt
 fre tmp
 set ipt
 
 lab main
 cmt init nine/ptr-size
 alc one
 get one
 rot one
 rot one
 rot one
 rot one
 rot one
 nnd vpt
 set tmp
 alc one
 get one
 nnd vpt
 nnd tmp
 fre tmp
 set nine
 
 cmt copies 0th byte of in to arg
 alc one
 get in
 set arg
 
 cmt set old-ipt
 alc ptr-size
 set tmp
 adr ipt
 drf vpt
 fre tmp
 set old-ipt
 
 cmt call not
 alc ptr-size
 set tmp
 adr not
 drf vpt
 fre tmp
 set ipt
 
 cmt init two
 alc one
 get one
 rot one
 rot one
 rot one
 rot one
 rot one
 rot one
 rot one
 set two
 
 cmt alloc new-out and sets 0th byte to ret from not
 alc two
 get ret
 set new-out
 
 cmt null terminates new-out
 alc ptr-size
 set tmp
 adr new-out
 get one
 drf vpt
 fre tmp
 cmt abusing the fact that out is currently 0
 get out
 
 cmt out = new-out
 alc ptr-size
 set tmp
 adr new-out
 drf vpt
 fre tmp
 set out
 
 cmt clean-up (in case we want to add more code)
 fre arg
 fre ret
 fre two
 
 cmt call loop
 alc ptr-size
 set tmp
 adr loop
 drf vpt
 fre tmp
 set ipt
Category:Examples
MASM/Bitwise or

:
==globals.masm==
 nine ptr-size
 arg
 arg1
 ret
 old-ipt
==or.masm==
 tmp
 
 lab or
 cmt tmp = not(arg)
 alc one
 get arg
 nnd vpt
 set tmp
 
 cmt ret = nand(not(arg1), tmp)
 alc one
 get arg1
 nnd vpt
 nnd tmp
 fre tmp
 set ret
 
 cmt set ipt to old-ipt + 9 to skip function call
 alc nine
 set tmp
 adr old-ipt
 get nine
 drf vpt
 fre tmp
 set ipt
==main.masm==
 or
 loop
 tmp
 two
 new-out
 
 lab loop
 cmt call loop
 alc ptr-size
 set tmp
 adr loop
 drf vpt
 fre tmp
 set ipt
 
 lab main
 cmt init nine/ptr-size
 alc one
 get one
 rot one
 rot one
 rot one
 rot one
 rot one
 nnd vpt
 set tmp
 alc one
 get one
 nnd vpt
 nnd tmp
 fre tmp
 set nine
 
 cmt copies 0th byte of in to arg
 alc one
 get in
 set arg
 
 cmt copies 1st byte of in to arg1
 alc ptr-size
 set tmp
 adr in
 get one
 drf vpt
 fre tmp
 set tmp
 alc one
 get tmp
 set arg1
 
 cmt set old-ipt
 alc ptr-size
 set tmp
 adr ipt
 drf vpt
 fre tmp
 set old-ipt
 
 cmt call or
 alc ptr-size
 set tmp
 adr or
 drf vpt
 fre tmp
 set ipt
 
 cmt init two
 alc one
 get one
 rot one
 rot one
 rot one
 rot one
 rot one
 rot one
 rot one
 set two
 
 cmt alloc new-out and sets 0th byte to ret from or
 alc two
 get ret
 set new-out
 
 cmt null terminates new-out
 alc ptr-size
 set tmp
 adr new-out
 get one
 drf vpt
 fre tmp
 cmt abusing the fact that out is currently 0
 get out
 
 cmt out = new-out
 alc ptr-size
 set tmp
 adr new-out
 drf vpt
 fre tmp
 set out
 
 cmt clean-up (in case we want to add more code)
 fre arg
 fre arg1
 fre ret
 fre two
 
 cmt call loop
 alc ptr-size
 set tmp
 adr loop
 drf vpt
 fre tmp
 set ipt
Category:Examples
MASM/Bitwise xnor

:
==globals.masm==
 nine ptr-size
 arg
 arg1
 ret
 old-ipt
==xnor.masm==
 tmp
 
 lab xnor
 cmt tmp = not(arg)
 alc one
 get arg
 nnd vpt
 set tmp
 
 cmt tmp = or(arg, arg1)
 alc one
 get arg1
 nnd vpt
 nnd tmp
 fre tmp
 set tmp
 
 cmt ret = nand(nand(arg, arg1), tmp)) = nand(nand(arg, arg1), or(arg, arg1))) = xnor(arg, arg1)
 alc one
 get arg
 nnd arg1
 nnd tmp
 fre tmp
 set ret
 
 cmt set ipt to old-ipt + 9 to skip function call
 alc nine
 set tmp
 adr old-ipt
 get nine
 drf vpt
 fre tmp
 set ipt
==main.masm==
 xnor
 loop
 tmp
 two
 new-out
 
 lab loop
 cmt call loop
 alc ptr-size
 set tmp
 adr loop
 drf vpt
 fre tmp
 set ipt
 
 lab main
 cmt init nine/ptr-size
 alc one
 get one
 rot one
 rot one
 rot one
 rot one
 rot one
 nnd vpt
 set tmp
 alc one
 get one
 nnd vpt
 nnd tmp
 fre tmp
 set nine
 
 cmt copies 0th byte of in to arg
 alc one
 get in
 set arg
 
 cmt copies 1st byte of in to arg1
 alc ptr-size
 set tmp
 adr in
 get one
 drf vpt
 fre tmp
 set tmp
 alc one
 get tmp
 set arg1
 
 cmt set old-ipt
 alc ptr-size
 set tmp
 adr ipt
 drf vpt
 fre tmp
 set old-ipt
 
 cmt call xnor
 alc ptr-size
 set tmp
 adr xnor
 drf vpt
 fre tmp
 set ipt
 
 cmt init two
 alc one
 get one
 rot one
 rot one
 rot one
 rot one
 rot one
 rot one
 rot one
 set two
 
 cmt alloc new-out and sets 0th byte to ret from xnor
 alc two
 get ret
 set new-out
 
 cmt null terminates new-out
 alc ptr-size
 set tmp
 adr new-out
 get one
 drf vpt
 fre tmp
 cmt abusing the fact that out is currently 0
 get out
 
 cmt out = new-out
 alc ptr-size
 set tmp
 adr new-out
 drf vpt
 fre tmp
 set out
 
 cmt clean-up (in case we want to add more code)
 fre arg
 fre arg1
 fre ret
 fre two
 
 cmt call loop
 alc ptr-size
 set tmp
 adr loop
 drf vpt
 fre tmp
 set ipt
Category:Examples
MASM/Bitwise xor

:
==globals.masm==
 nine ptr-size
 arg
 arg1
 ret
 old-ipt
==xor.masm==
 tmp
 
 lab xor
 cmt tmp = not(arg)
 alc one
 get arg
 nnd vpt
 set tmp
 
 cmt tmp = or(arg, arg1)
 alc one
 get arg1
 nnd vpt
 nnd tmp
 fre tmp
 set tmp
 
 cmt ret = not(nand(nand(arg, arg1), tmp))) = not(xnor(arg, arg1)) = xor(arg, arg1)
 alc one
 get arg
 nnd arg1
 nnd tmp
 fre tmp
 nnd vpt
 set ret
 
 cmt set ipt to old-ipt + 9 to skip function call
 alc nine
 set tmp
 adr old-ipt
 get nine
 drf vpt
 fre tmp
 set ipt
==main.masm==
 xor
 loop
 tmp
 two
 new-out
 
 lab loop
 cmt call loop
 alc ptr-size
 set tmp
 adr loop
 drf vpt
 fre tmp
 set ipt
 
 lab main
 cmt init nine/ptr-size
 alc one
 get one
 rot one
 rot one
 rot one
 rot one
 rot one
 nnd vpt
 set tmp
 alc one
 get one
 nnd vpt
 nnd tmp
 fre tmp
 set nine
 
 cmt copies 0th byte of in to arg
 alc one
 get in
 set arg
 
 cmt copies 1st byte of in to arg1
 alc ptr-size
 set tmp
 adr in
 get one
 drf vpt
 fre tmp
 set tmp
 alc one
 get tmp
 set arg1
 
 cmt set old-ipt
 alc ptr-size
 set tmp
 adr ipt
 drf vpt
 fre tmp
 set old-ipt
 
 cmt call xor
 alc ptr-size
 set tmp
 adr xor
 drf vpt
 fre tmp
 set ipt
 
 cmt init two
 alc one
 get one
 rot one
 rot one
 rot one
 rot one
 rot one
 rot one
 rot one
 set two
 
 cmt alloc new-out and sets 0th byte to ret from xor
 alc two
 get ret
 set new-out
 
 cmt null terminates new-out
 alc ptr-size
 set tmp
 adr new-out
 get one
 drf vpt
 fre tmp
 cmt abusing the fact that out is currently 0
 get out
 
 cmt out = new-out
 alc ptr-size
 set tmp
 adr new-out
 drf vpt
 fre tmp
 set out
 
 cmt clean-up (in case we want to add more code)
 fre arg
 fre arg1
 fre ret
 fre two
 
 cmt call loop
 alc ptr-size
 set tmp
 adr loop
 drf vpt
 fre tmp
 set ipt
Category:Examples
MASM/Cat program

:
==globals.masm==
 nine ptr-size
==main.masm==
 tmp
 loop
 
 lab loop
 cmt goto loop
 alc ptr-size
 set tmp
 adr loop
 drf vpt
 fre tmp
 set ipt
 
 lab main
 cmt init nine (aka ptr-size)
 alc one
 get one
 rot one
 rot one
 rot one
 rot one
 rot one
 nnd vpt
 set tmp
 alc one
 get one
 nnd vpt
 nnd tmp
 fre tmp
 set nine
 
 cmt set out to in
 alc ptr-size
 set tmp
 adr in
 drf vpt
 fre tmp
 set out
 
 cmt goto loop
 alc ptr-size
 set tmp
 adr loop
 drf vpt
 fre tmp
 set ipt
Category:Examples
MASM/Print A

:
==globals.masm==
 nine ptr-size
==main.masm==
 loop
 _64 _65
 two
 new-out
 tmp
 
 lab loop
 alc ptr-size
 set tmp
 adr loop
 drf vpt
 fre tmp
 set ipt
 
 
 lab main
 cmt init nine
 alc one
 get one
 rot one
 rot one
 rot one
 rot one
 rot one
 nnd vpt
 set tmp
 alc one
 get one
 nnd vpt
 nnd tmp
 fre tmp
 set nine
 
 cmt init _65
 alc one
 get one
 rot one
 rot one
 nnd vpt
 set _64
 alc one
 get one
 nnd vpt
 nnd _64
 fre _64
 set _65
 
 cmt init two
 alc one
 get one
 rot one
 rot one
 rot one
 rot one
 rot one
 rot one
 rot one
 set two
 
 cmt set 0th value of new-out (to _65, aka 'A')
 alc two
 get _65
 set new-out
 
 cmt set 1st value of new-out (to 0, aka string termination)
 alc ptr-size
 set tmp
 adr new-out
 get one
 drf vpt
 cmt abusing the fact that out is currently 0
 get out
 fre tmp
 
 cmt set out to new-out
 alc ptr-size
 set tmp
 adr new-out
 drf vpt
 fre tmp
 set out
 
 cmt goto loop
 alc ptr-size
 set tmp
 adr loop
 drf vpt
 fre tmp
 set ipt
Category:Examples
MATH

MATH is a language by User:Fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff where you make your own operations.
== Operations ==
Operations are defined like this:
 operation_name ::= code # With 𝓍 on the left and 𝓎 on the right
e.g.
 ⅟ ::= 1÷𝓎
== Included Operations ==
 +: addition
 -: subtraction
 ×: multiplaction
 ÷: division
== Misc. ==
The final result of the equation is printed.
Order of operations is not supported.
== Examples ==
=== Truth-machine ===
 ⊤ ::= 1÷𝓍⊤0
 [input]⊤0
=== Looping counter ===
 ∆ ::= 𝓍+1∆0
 1∆0
Category:Nested Category:Output only Category:Languages Category:Unimplemented Category:2024
MATL

MATL /'mæt.ˌl/ is a programming language based on MATLAB/Octave and suitable for code golf. 
==Introduction==
The MATL language is stack-oriented. Data are pushed onto and popped out
of a stack. Functions may take a number of elements from the stack (usually those
at the top) and push one or more outputs onto the stack. Since the functions use
data that’s already present in the stack, reverse Polish (or postfix) notation is used.
To ease stack handling, values from the stack can
also be copied and pasted using several clipboards. These are similar to variables
in other stack-based code-golf programming languages.
The main goal in designing the language has been to keep it as close to MATLAB as possible. MATL includes functions equivalent to most commonly used MATLAB functions. It should be very easy for a MATLAB user to start programming
in MATL within minutes.
==Language specification and compiler==
The specification document and compiler files can be found on GitHub. The compiler works in MATLAB R2015b and newer versions. Probably in older versions too, except for some specific functions. It is also compatible with Octave 4.0.0 and newer. The compiler tries to ensure consistent behaviour in both platforms.
There are also two online compilers, located at Try It Online! and MATL Online!
The language is subject to changes. This may cause old MATL code not to run in newer versions. However, old versions of the compiler and specification are kept in GitHub.
==Example programs==
===Hello, world!===
 'Hello, world!'
The contents of the stack are automatically printed at the end of the program.
To run this with the compiler you need to duplicate quotation marks, as usual, and include the whole program within single quotation marks. Or type matl, then enter 'Hello, world!' on a separate line, then press enter twice.
===Fibonacci sequence===
Inputs a number n ≥ 2 and prints the first n Fibonacci numbers.
 1ti2-:"yy+
 1 % Number literal 
 t % Duplicate top element 
 i % Input number n
 2 % Number literal
 - % Subtract. Produces n-2
 : % Vector of equally spaced values: [1, 2, ... , n-2]
 " % For loop. There will be n-2 iterations
 y % Duplicate second-top element
 y % Duplicate second-top element
 + % Addition of top two elements
 % Implicitly end for loop
 % Implicitly display stack contents, bottom to top 
This can be run with the command matl '1ti2-:"yy+'. Or try it online!
Category:Languages
Category:2015
Category:Stack-based
Category:Golfing language
Category:Implemented
Category:Turing complete
Category:Graphical Output
MC14500B

The MC14500B is a 1-bit microcontroller designed by Motorola featuring a minimal set of 16 instructions (4-bit each), one 1-bit register and a 1-bit data bus.
Conventionally, the register is initially set to 0. If the input signals run out, the signal stays at the last inputted bit.
== Instruction set ==
Instruction code (in binary)	Mnemonic	Description
0000 	NOPO 	No change in registers. Set Flag O to 1.
0001 	LD 	Load result register. Data -> R
0010 	LDC 	Load complement to register. NOT(Data) -> R
0011 	AND 	Logical and. R AND Data -> R
0100 	ANDC 	Complement and. NOT(R AND Data) -> R
0101 	OR 	Logical or. R OR Data -> R
0110 	ORC 	Complement or. NOT(R OR Data) -> R
0111 	XNOR 	Exclusive nor. NOT(R XOR Data) -> R
1000 	STO 	Store. R -> Data
1001 	STOC 	Store complement. NOT(R) -> Data
1010 	IEN 	Input enable. Input -> Register
1011 	OEN 	Output enable. Register -> Output
1100 	JMP 	Jump to the start of the program.
1101 	RTN 	Skip the next instruction.
1110 	SKZ 	Skip the next instruction if the register is 0.
1111 	NOPF 	No change in registers. Set Flag F to 1.
== "implementation" ==
# Truth-machine: ABEC
input_signal = [0]
curr = 0
Data = 0
Acc = 0
code = "ABEC"
ptr = 0
while ptr < len(code):
	i = code[ptr]
	if i == "1":
		R = Data
	if i == "2":
		R = 1 - Data
	if i == "3":
		R = R & Data
	if i == "4":
		R = 1 - (R & Data)
	if i == "5":
		R = R | Data
	if i == "6":
		R = 1 - (R | Data)
	if i == "7":
		R = 1 - (R ^ Data)
	if i == "8":
		Data = R
	if i == "9":
		Data = 1 - R
	if i == "A":
		R = input_signal[curr % len(input_signal)]
		curr += 1
	if i == "B":
		print(R,end="")
	if i == "C":
		ptr = 0
		continue
	if i == "D":
		ptr += 1
	if i == "E":
		if R == 0:
			ptr += 1
	ptr += 1
== External Links ==
* Wikipedia
* MC14500 Website
* MC14500 Wiki
* Hub pages description
* MC14500B in CPU World
* MC14500 in Decode Systems
* All Solutions in CGCC in MC14500
Category:Languages
Category:Implemented
Category:Before 1993
MCA v1.1

MCA v1.1 is an assembly language for a mechanical computer invented by User:Almostahexagon. It is the new version of mecomp, with many changes to the instruction set and computer in general. This page shows all the new things in MCA/Mecomp v1.1, so see MCA (Old) to get the background information.
== Changes ==
Mecomp v1.1 is still using the same Harvard architecture.
* Instructions are now 4-bit
** Previously 3
* Added an accumulator
** It can hold an 8-bit number
** Along with this, math operations have changed (see below)
* Changed math operations
** Operations now do memory + accumulator, instead of M0 + M1.
* Changed how operation results are stored
** Result is stored in the destination address if its value is not zero, accumulator otherwise.
* RAM style has changed
** Before, the RAM used a bunch of mechanical bits. This has been changed, and now the RAM is a circular disc with a head, kind of like an HDD. The head has 8 pins that can flip bits.
* Changed amount of bytes in the RAM
** 256 bytes was way too much to build, so it has been decreased to 32 bytes.
== New MCA instruction set ==
=== Memory and input ===
Opcode	Name	Full name 	Parameter A 	Parameter B	Function
0000 	UIP 	User input	1 byte from user (00-FF)	M(address) 	User loads a value to M(address).
0001 	LOD 	Load 	#(value) 	M(address) 	Loads [value] to M(address).
0010 	CPY 	Copy 	M(adrs0) 	M(adrs1) 	Copies the value of M(adrs0) to M(adrs1).