nyuuzyou/wikis huggingface dataset:
Mom please get me so me zucchini from sho p

mom please get me so me zucchini from sho p is an imperative, stack-based work-in-progress esoteric programming language with functional elements, designed by User:Bigmac. 
An interesting feature is that, by specification, there are no errors or exceptions possible in the language: all programs run until input has been exhausted. A program that stops unexpectedly is due to a faulty implementation. 
==Specification==
Because the language is still a work-in-progress, detailed specifications will be rendered obsolete too quickly to be worth writing. Comments are currently done bu doing something like this: <~this is a comment~>.
==External resources==
* The reference mom please get me so me zucchin from sho p implementation; an interpreter written in JavaScript.. Note that this is not yet available because the author cannot download Git yet because of internet issues.
Category:Languages
Category:2019
Category:Stack-based
Category:Unknown_computational_class
Category:Implemented
Momema

Momema is a boring imperative language with memory-mapped control flow created by User:Challenger5 in 2018. Its only real gimmick is to unify (or, more accurately, to lump) jump labels and (relative) jump statements. It was created due to a dissatisfaction with many similar languages that were in common use on PPCG, and to experiment with the creation of a very high quality interpreter (it supports a full interactive mode with a REPL, breakpoints, state debugging, etc.).
== Language Overview ==
A Momema program has access to a doubly-infinite tape of unbounded integers, indexed by unbounded integers. A program consists of a list of assignment statements. An assignment statement consists of two expressions, and has the semantics of storing the result of the second expression in the tape cell given by the result of the first.
 4 0
This assigns the value of the cell at index 4 to 0, which is useless since all cells are initialized to 0 anyway.
 -8 0
The cells -8 and -9 are memory mapped for I/O. Reading and writing numbers from the cell -9 will output and input the corresponding Unicode character, respectively. -8 is the same, but works with numbers rather than character codes. -9 will return -1 on EOF; -8 will simply halt the program.
 0 *-8
 -8 *0
The * operator "dereferences" an integer, returning the value of the tape cell at that location. This program reads from cell -8 to read an integer from STDIN, and then writes to -8 to write it back out.
 -8 + 5 5
The prefix + operator adds two numbers. This prints 10.
 0 = 0
 1 = -5
The = operator returns 0 if its argument is 0, and 1 otherwise.
 j 0
 j -1
The j command is both a label and a jump: it takes an argument and jumps forward (or backwards, if negative) past that many labels. It follows that an argument of 0 does nothing, and only serves as a label.
This program is an infinite loop.
 j 0
 r *5
 5 1
 j 1
 r 0
In fact, any string of lowercase characters acts like j, and only pays attention to jumps with their own label.
In this program, execution proceeds as follows: the initial j has an argument of 0, and does nothing. The first r gets the value at cell 5, returning 0, so it, too, does nothing. After this, we encounter an instruction that sets cell 5 to 1. The second j instruction has an argument of 1, but since there are no further j jumps in the program, it wraps around and starts searching from the beginning, causing a jump to the first j. This time, the argument to r is 1, so we jump forward to the second r, ending the program.
More information about the langauge, as well as an implementation, can be found on github.
Category:2018
Category:Implemented
Category:Languages
Category:Turing complete
Monicelli

Monicelli is an esoterical programming language based on the concept of "supercazzole" from the movie Amici Miei, a masterpiece of Italian comedy, directed by the Italian filmmaker and screenwriter Mario Monicelli, after whom the language is named. The language was created by Stefano Sanfilippo in 2014.
A supercazzola - also spelled "supercazzora" - is an Italian word describing a comically deceptive discourse composed mostly of gibberish and made-up words. However, according to Sanfilippo, this definition «sadly does not capture the true essence of what a "supercazzola" [...] is»Monicelli's README.md. Sanfilippo created the language as a way to explain the concept of supercazzola to the international public.
== Example ==
Several examples of Monicelli programs are available in the examplesMonicelli examples folder in the Monicelli repository.
=== Ciao, mondo! (Hello, world!) ===
This is a simple version of the Hello, world program, you can find a more complex one, which is closer to a true supercazzola in the Monicelli repository.Monicelli's Hello world
# ciao-mondo.mc
#
# Author: Cristian Consonni <cristian@balist.es>
# Released under MIT
#
# This program prints the string 'Ciao, mondo!\n' - which is Italian for
# 'Hello, world!\n'.
#
# The program declares a `char` variable called `tarapiapiatapioco` and then
# puts in the values need for each letter and prints them right away.
# These are the char values:
#
# C i a o , · m o n d o ! \n
# 67 105 97 111 44 32 109 111 110 100 111 33 10
Lei ha clacsonato
voglio la tarapiatapioco, Mascetti
tarapiatapioco come se fosse 67, tarapiatapioco a posterdati # C
tarapiatapioco come se fosse 105, tarapiatapioco a posterdati # i
tarapiatapioco come se fosse 97, tarapiatapioco a posterdati # a
tarapiatapioco come se fosse 111, tarapiatapioco a posterdati # o
tarapiatapioco come se fosse 44, tarapiatapioco a posterdati # ,
tarapiatapioco come se fosse 32, tarapiatapioco a posterdati #
tarapiatapioco come se fosse 109, tarapiatapioco a posterdati # m
tarapiatapioco come se fosse 111, tarapiatapioco a posterdati # o
tarapiatapioco come se fosse 110, tarapiatapioco a posterdati # n
tarapiatapioco come se fosse 100, tarapiatapioco a posterdati # d
tarapiatapioco come se fosse 111, tarapiatapioco a posterdati # o
tarapiatapioco come se fosse 33, tarapiatapioco a posterdati # !
tarapiatapioco come se fosse 10, tarapiatapioco a posterdati # \n
vaffanzum!
which can be compiled with:
$ mcc -o ciao-mondo ciao-mondo.mc
this will produce an executable called, ciao-mondo, which when executed will print "Ciao, mondo!":
$ ./ciao-mondo
Ciao, mondo!
== Bibliography ==
* Monicelli GitHub repo
* Supercazzola. (April, 6th 2021). Wikipedia, he free Encyclopedia. Visited on 2021-05-08 11:50. 
== References ==
MonkeyCode

MonkeyCode is a programming language created by User:Wezyap and first released in 2006. Unfortunately, pretty much no information on the language now exists on the Internet.
From surviving IRC logs, it appears that the language was reasonably expressive and had infinite memory, but had no control flow operations, and therefore was sub-Turing. Although there was an implementation, it was only available as a Windows binary
== External resources ==
* 
* IRC log discussing MonkeyCode; possibly the only remaining source to the language 
Category:Languages Category:2006 Category:Implemented Category:Unknown computational class
Monolog

Monolog (MONOLOG) is a programming language created by User:CMinusMinus.
Almost every thing you do, is for defining a variable. You can call functions, do simple maths and so on.
==Variables==
Lets define variable x with a value of "Hello":
 x <- "Hello"
Lets define variable y with a value of x:
 y <- x
Now, lets add " World!" to y:
 y <- y <- " World!"
We added arg " World!" to arg "Hello".
Integers doesn´t exist.
==Functions==
To call a function, we have to put the name of it in brackets.
Name 	Action
reversed	reverse arg
b64e 	Base64 Encode arg
b64d 	Base64 Decode arg
out 	Output arg
outln 	Output arg + \n
input 	set arg to user input
request 	request an url with arg
ping 	ping arg and return time
len 	return length of arg
active 	special variable "active" = arg
pass 	pass and reset arg
cuts 	cut arg by int(active) at start: arg[int(active):]
cute 	cut arg by int(active) at end: arg[:int(active)]
os 	run arg as os.system command
run 	parse arg
same 	go on in line if arg == active
notsame 	go on in line if arg != active
double 	returns arg + arg
exit 	exit loop
crepeat 	returns number of loops the program did
creset 	reset number of loops the program did
Lets call a function:
 a <- (reversed) <- "Hello"
We defined variable a with a value of reversed("Hello")
But what if we want to do a = a + reversed("Hello)?
In this case we can easily do:
 a <- (*reversed) <- "Hello"
How to output a text/variable?
To do this, we can use (out) or (outln), which adds a line break at the end.
So if we want to define variable X with a value of "foo" and output it at the same time, we can do:
 X <- (outln) <- "foo"
BUT what if we just want to output it? BOOM:
 * <- (outln) <- "foo"
A "*" as name will pass the variable-definition!
==MONOLOG Settings==
To change settings, you can use the "$MONOLOG" command.
 $MONOLOG [OPTION] [1/0]
Example: (Changing "logvar" to true (1))
 $MONOLOG logvar 1
Option 	Action
logvar 	Show all variables at end of program
error.ignore 	Ignore error
error.continue 	Continue on error
program.repeat 	Restart program at end
program.firsttime	First time running program?
==Examples==
===Hello, World!===
Stage 1:
 * <- (outln) <- "Hello, World!"
Stage 2:
 hw <- "Hello, World!"
 * <- (outln) <- hw
===cat===
Stage 1:
 * <- (outln) <- (input)
Stage 2:
 * <- (outln) <- (input) <- (out) <- "Enter Text: "
===Count to 69===
...
 $MONOLOG program.repeat 1
 * <- (outln) <- (*crepeat) <- "Hello, World! > "
 stopat <- "69"
 * <- (active) <- stopat
 * <- (outln) <- "DONE!" <- (pass) <- (exit) <- (same) <- (crepeat)
===Self Interpreter===
 $MONOLOG program.repeat 1
 start: * <- (outln) <- "SELF INTERPRETER!"
 * <- (run) <- (input)
==External Links==
Github
Category:Languages Category:Implemented
Monte

Monte is an object-capability programming language in the tradition of E. It was first discussed at PyCon 2015 by W. Allen "dash" Short, Corbin Simpson, and Brian Warner; designed by Short & Simpson in collaboration with Michael "mythmon" Cooper, E. Dunham, and Justin Noah; and implemented by Short & Simpson. Monte is intended to incrementally improve upon Python's syntax and E's object-capability semantics, and was originally designed as an alternative to wikipedia:Twisted Python. Like many flavors of E, Monte directly supports the actor model and messages may be asynchronously sent to objects without blocking.
== Hello World ==
One way to approach Monte is as a networking engine. The following program, archived on GitHub, implements an RFC 862-compliant echo service listening on TCPv4 port 7. To keep the program short, a few lines of flow control are imported from a library.
 import "lib/streams" =~ [=> flow :DeepFrozen]
 exports (main)
 def main(_, => makeTCP4ServerEndpoint) :Vow[Int] as DeepFrozen:
 def endpoint := makeTCP4ServerEndpoint(7)
 endpoint.listenStream(flow)
 # Idiom for running forever.
 return when (Ref.promise()[0]) -> { 0 }
Another way to approach Monte is as a flavor of E. In that case, the following maker implements The Mint:
 def makeMint():
 def [sealer, unsealer] := makeBrandPair("mint")
 return def mint.makePurse(var balance :(Int >= 0)):
 def decr(amount :(0..balance)) :Void { balance -= amount }
 return object purse:
 to getBalance() :Int { return balance }
 to sprout() { return mint.makePurse(0) }
 to getDecr() { return sealer.seal(decr) }
 to deposit(amount :(Int >= 0), src) :Void:
 unsealer.unseal(src.getDecr())(amount)
 balance += amount
== Running Monte ==
The official way to run the reference implementation is via Nix Flakes. Be on a Linux system supported by RPython (amd64 and arm64 are known to work) and run:
 $ nix shell github:monte-language/typhon
This may take some time. User:Corbin maintains a Cachix cache which can trade local build resources for bandwidth on amd64. Once built, a REPL can be started with:
 $ monte repl
 ⛰ 
The REPL may take a moment to start. The prompt is a little Unicode mountain (⛰). Once it loads, you can try some arithmetic:
 ⛰ 1 + 1
 Result: 2
Category:2015
Category:Turing complete
Category:Implemented
MoonScript

MoonScript is a language invented by an advanced GPT AI neural network.https://chat.openai.com/chat Previous experiment was GPTLang - an esolang invented by a much smaller and simpler GPT neural network.
Q: Can you invent an esoteric programming language, please?
ChatGPT: Sure, here is one that I just came up with. This language is called "MoonScript" and it is designed to be as simple and minimalistic as possible. The only data type in MoonScript is a number, and the only operation allowed is incrementing or decrementing a number by one.
Syntax
MoonScript programs are made up of a series of instructions, each of which is a single character. Here are the available instructions:
* + - Increment the current number.
* - - Decrement the current number.
* . - Output the current number as a character (i.e. 65 becomes "A").
* , - Input a character and store its ASCII value as the current number.
Examples
Here is a simple MoonScript program that takes an input character, increments it by one, and outputs the result:
 ,+.-.
This program first inputs a character (e.g. "A"), then increments its ASCII value to 66 ("B"), then decrements it back to 65 ("A"), and finally outputs it.
Limitations
One major limitation of MoonScript is that it can only operate on numbers within the range of a signed 8-bit integer (i.e. from -128 to 127). This means that it cannot handle numbers larger than 127 or decimal fractions. Additionally, the only way to output or input data is as ASCII characters, so it is not possible to directly work with other data types or formats.
Despite these limitations, MoonScript can still be used to write simple programs that perform basic operations on numbers.
Turing Completeness
MoonScript is not Turing complete because it lacks the ability to implement conditional statements and loops, which are required for arbitrary computations. Despite this limitation, MoonScript can still be used for simple programs and as a tool for teaching programming concepts. Adding Turing completeness to MoonScript can increase complexity and detract from its original simplicity.
==Interpreter==
* Common Lisp implementation of the MoonScript programming language.
Category:Languages Category:Total Category:Unusable for programming Category:2022 Category:Implemented
Category:Generated by AI
MoreMathRPN/Brainfuck interpreter

← go back
Brainfuck can also be simulated; if you had any doubts of Turing completeness, this is even better
 inputS "Enter brainfuck"
 hold iLen
 del 0
 m $iLen 1
 flip
 "remove invalid characters
 repeat $iLen
 >>> 0
 1
 -
 -> 1
 ind ]1 0
 del 2
 >> 0
 "+
 43
 -
 >> 1
 ",
 44
 -
 *
 >> 1
 "-
 45
 -
 *
 >> 1
 ".
 46
 -
 *
 >> 1
 "<
 60
 -
 *
 >> 1
 ">
 62
 -
 *
 >> 1
 "[
 91
 -
 *
 >> 1
 "]
 93
 -
 *
 1
 -> 1
 0
 compare
 >> 0
 *
 -
 4
 *
 jmp ]0
 del 0
 del 0
 jmp 3
 del 0
 <- 1
 next
 del 0
 #
 hold iLen
 del 0
 m $iLen 1
 hold instructions
 del 0
 "brackets
 -1
 m 1 1
 repeat $iLen
 >>> 0
 1
 -
 place instructions
 ind ]1 0
 del 1
 >> 0
 91
 -
 0
 compare
 >> 0
 *
 6
 *
 jmp ]0
 "[
 del 0
 del 0
 m 1 1
 aug
 jmp 33
 del 0
 93
 -
 0
 compare
 >> 0
 *
 21
 *
 jmp ]0
 "]
 del 0
 >>> 0
 -> 2
 rip
 ind 0 0
 >> 0
 del 2
 -> 3
 -> 1
 -
 2
 +
 -> ]0
 -> 4
 <- ]2
 -> 2
 <- 3
 del 0
 del 0
 jmp 5
 del 0
 del 0
 0
 <- 1
 next
 del 0
 m $iLen 1
 hold jumps
 del 0
 0
 hold pointer
 -1
 hold pc
 del 0
 1
 hold size
 del 0
 "begin execution
 place pc
 1
 +
 hold pc
 place iLen
 -
 1
 +
 step
 207
 *
 jmp ]0
 del 0
 place size
 place pointer
 -
 place instructions
 ind $pc 0
 del 1
 >> 0
 43
 -
 0
 compare
 >> 0
 *
 11
 *
 jmp ]0
 "+
 del 0
 del 0
 -> ]0
 1
 +
 256
 %
 <- ]1
 del 0
 jmp -38
 del 0
 >> 0
 44
 -
 0
 compare
 >> 0
 *
 27
 *
 jmp ]0
 ",
 del 0
 del 0
 del ]0
 inputS "Input a character"
 hold len
 step
 1
 <- 1
 -
 9
 *
 jmp ]0
 del 0
 m $len 1
 flip
 ind 0 0
 256
 %
 del 1
 jmp 3
 del 0
 0
 <- ]1
 del 0
 lose len
 jmp -75
 del 0
 >> 0
 45
 -
 0
 compare
 >> 0
 *
 11
 *
 jmp ]0
 "-
 del 0
 del 0
 -> ]0
 1
 -
 256
 %
 <- ]1
 del 0
 jmp -96
 del 0
 >> 0
 46
 -
 0
 compare
 >> 0
 *
 8
 *
 jmp ]0
 ".
 del 0
 del 0
 -> ]0
 outputC ]0
 <- ]1
 del 0
 jmp -114
 del 0
 >> 0
 60
 -
 0
 compare
 >> 0
 *
 23
 *
 jmp ]0
 "<
 del 0
 del 0
 del 0
 place pointer
 step
 8
 *
 jmp ]0
 <- $size
 place size
 1
 +
 hold size
 del 0
 jmp 7
 del 0
 place pointer
 1
 -
 hold pointer
 del 0
 jmp -147
 del 0
 >> 0
 62
 -
 0
 compare
 >> 0
 *
 20
 *
 jmp ]0
 ">
 del 0
 del 0
 del 0
 place size
 place pointer
 1
 +
 hold pointer
 -
 step
 5
 *
 jmp ]0
 place size
 1
 +
 hold size
 del 0
 jmp -177
 del 0
 91
 -
 0
 compare
 >> 0
 *
 14
 *
 jmp ]0
 "[
 del 0
 >> ]0
 step
 5
 *
 jmp ]0
 place jumps
 ind $pc 0
 del 1
 hold pc
 del 0
 del 0
 jmp -200
 "]
 del 0
 >> ]0
 step
 1
 <- 1
 -
 6
 *
 jmp ]0
 place jumps
 ind $pc 0
 del 1
 hold pc
 del 0
 del 0
 del 0
 jmp -217
 del 0
Using similar methods, one could write a self interpreter, but please don't waste your precious time on that, the run command is much more capable
MoreMathRPN/Implicit plotter

← go back
Using Matrices in neat ways, you can graph any function in the output
 "x^2-y^2-2=0
 chars "place x\n>> 0\n*\nplace y\n>> 0\n*\n-\n2\n-"
 hold f
 del 0
 m $f 1
 flip
 hold f
 del 0
 5.1
 hold y
 del 0
 -1
 m 1 1
 repeat 52
 >>> 0
 26.5
 -
 5
 /
 hold x
 del 0
 place f
 run
 0
 compare
 m 1 1
 aug
 next
 flip
 rip
 del 0
 flip
 T
 repeat 51
 25.5
 >>> 0
 -
 5
 /
 hold y
 del 0
 -1
 m 1 1
 repeat 52
 >>> 0
 26.5
 -
 1/5
 *
 hold x
 del 0
 place f
 run
 0
 compare
 m 1 1
 aug
 next
 flip
 rip
 del 0
 flip
 T
 aug
 repeat 51
 >>> 0
 >> 0
 1
 -
 -> 2
 ind 0 ]1
 <- 3
 ind 1 ]1
 <- 3
 ind 0 ]2
 <- 3
 ind 1 ]2
 del 2
 del 2
 repeat 3
 -> 2
 >> 1
 0
 compare
 >> 0
 *
 4
 *
 jmp ]0
 del 1
 del 1
 jmp 17
 del 0
 >> 0
 0
 compare
 >> 0
 *
 4
 *
 jmp ]0
 del 1
 del 1
 jmp 5
 del 0
 +
 2
 /
 next
 >> 0
 *
 4
 *
 jmp ]0
 "crossing
 del 0
 outputS "#"
 jmp 39
 del 0
 >>> 0
 26
 compare
 >> 0
 *
 16
 *
 jmp ]0
 "x=0
 del 0
 >>> 1
 26
 compare
 >> 0
 *
 4
 *
 jmp ]0
 "y=0
 del 0
 outputS "+"
 jmp 18
 del 0
 outputS "|"
 jmp 15
 del 0
 >>> 1
 26
 compare
 >> 0
 *
 4
 *
 jmp ]0
 "y=0
 del 0
 outputS "-"
 jmp 3
 del 0
 outputS " "
 next
 outputS "\n"
 rip
 del 1
 next
Produces the following output:
# | #
# | #
## | ##
 ## | ## 
 ## | ## 
 ## | ## 
 ## | ## 
 ## | ## 
 ## | ## 
 ## | ## 
 ## | ## 
 ## | ## 
 ## | ## 
 ## | ## 
 ## | ## 
 ## | ## 
 ## | ## 
 ## | ## 
 # | # 
 ## | ## 
 ## | ## 
 # | # 
 ## | ## 
 ## | ## 
 # | # 
------------------#------+------#------------------
 # | # 
 ## | ## 
 ## | ## 
 # | # 
 ## | ## 
 ## | ## 
 # | # 
 ## | ## 
 ## | ## 
 ## | ## 
 ## | ## 
 ## | ## 
 ## | ## 
 ## | ## 
 ## | ## 
 ## | ## 
 ## | ## 
 ## | ## 
 ## | ## 
 ## | ## 
 ## | ## 
 ## | ## 
## | ##
# | #
# | #
MoreMathRPN/Quine

← go back
Quines are a bit tricky, these programs have three parts: the data (the initial list of numbers), the number printer (first repeat), and the text printer (second repeat). The numbers are chosen to be the unicode values of all the code's characters in order.
e.g. the first number is 35, and the first command is #. If I didn't indent the program, a lot of the 32's would be removed. 
 35
 10
 104
 111
 108
 100
 32
 108
 10
 100
 101
 108
 32
 48
 10
 109
 32
 36
 108
 32
 49
 10
 114
 101
 112
 101
 97
 116
 32
 36
 108
 10
 32
 62
 62
 62
 32
 48
 10
 32
 49
 10
 32
 45
 10
 32
 45
 62
 32
 49
 10
 32
 105
 110
 100
 32
 93
 49
 32
 48
 10
 32
 100
 101
 108
 32
 50
 10
 32
 111
 117
 116
 112
 117
 116
 86
 10
 32
 111
 117
 116
 112
 117
 116
 67
 32
 49
 48
 10
 110
 101
 120
 116
 10
 114
 101
 112
 101
 97
 116
 32
 36
 108
 10
 32
 62
 62
 62
 32
 48
 10
 32
 49
 10
 32
 45
 10
 32
 45
 62
 32
 49
 10
 32
 105
 110
 100
 32
 93
 49
 32
 48
 10
 32
 100
 101
 108
 32
 50
 10
 32
 111
 117
 116
 112
 117
 116
 67
 32
 93
 48
 10
 32
 100
 101
 108
 32
 48
 10
 110
 101
 120
 116
 #
 hold l
 del 0
 m $l 1
 repeat $l
 >>> 0
 1
 -
 -> 1
 ind ]1 0
 del 2
 outputV
 outputC 10
 next
 repeat $l
 >>> 0
 1
 -
 -> 1
 ind ]1 0
 del 2
 outputC ]0
 del 0
 next
if you consider outputV to be cheating:
 35
 10
 104
 111
 108
 100
 32
 108
 10
 100
 101
 108
 32
 48
 10
 109
 32
 36
 108
 32
 49
 10
 114
 101
 112
 101
 97
 116
 32
 36
 108
 10
 32
 62
 62
 62
 32
 48
 10
 32
 49
 10
 32
 45
 10
 32
 45
 62
 32
 49
 10
 32
 105
 110
 100
 32
 93
 49
 32
 48
 10
 32
 100
 101
 108
 32
 50
 10
 32
 49
 10
 32
 104
 111
 108
 100
 32
 100
 10
 32
 100
 101
 108
 32
 48
 10
 32
 62
 62
 32
 48
 10
 32
 49
 48
 10
 32
 37
 10
 32
 45
 62
 32
 49
 10
 32
 49
 48
 10
 32
 47
 10
 32
 102
 108
 111
 111
 114
 10
 32
 49
 10
 32
 62
 62
 32
 49
 10
 32
 115
 116
 101
 112
 10
 32
 45
 10
 32
 54
 10
 32
 42
 10
 32
 106
 109
 112
 32
 93
 48
 10
 32
 32
 100
 101
 108
 32
 48
 10
 32
 32
 112
 108
 97
 99
 101
 32
 100
 10
 32
 32
 49
 10
 32
 32
 43
 10
 32
 32
 106
 109
 112
 32
 45
 50
 48
 10
 32
 100
 101
 108
 32
 48
 10
 32
 100
 101
 108
 32
 48
 10
 32
 114
 101
 112
 101
 97
 116
 32
 36
 100
 10
 32
 32
 52
 56
 10
 32
 32
 43
 10
 32
 32
 111
 117
 116
 112
 117
 116
 67
 32
 93
 48
 10
 32
 32
 100
 101
 108
 32
 48
 10
 32
 110
 101
 120
 116
 10
 32
 111
 117
 116
 112
 117
 116
 67
 32
 49
 48
 10
 110
 101
 120
 116
 10
 114
 101
 112
 101
 97
 116
 32
 36
 108
 10
 32
 62
 62
 62
 32
 48
 10
 32
 49
 10
 32
 45
 10
 32
 45
 62
 32
 49
 10
 32
 105
 110
 100
 32
 93
 49
 32
 48
 10
 32
 100
 101
 108
 32
 50
 10
 32
 111
 117
 116
 112
 117
 116
 67
 32
 93
 48
 10
 32
 100
 101
 108
 32
 48
 10
 110
 101
 120
 116
 #
 hold l
 del 0
 m $l 1
 repeat $l
 >>> 0
 1
 -
 -> 1
 ind ]1 0
 del 2
 1
 hold d
 del 0
 >> 0
 10
 %
 -> 1
 10
 /
 floor
 1
 >> 1
 step
 -
 6
 *
 jmp ]0
 del 0
 place d
 1
 +
 jmp -20
 del 0
 del 0
 repeat $d
 48
 +
 outputC ]0
 del 0
 next
 outputC 10
 next
 repeat $l
 >>> 0
 1
 -
 -> 1
 ind ]1 0
 del 2
 outputC ]0
 del 0
 next
Morsefuck

Morsefuck is an esoteric language completely based on Brainfuck.
It is inspired by the obfuscation created by this language, but taking it even further. It was created on December 18, 2016, by thoga31.
By using a three-combination of dots (.) and dashes (-) - the basis of Morse Code, thus this name -, the set of eight operators is possible.
List of operators:
 > .-- W
 < --. G
 + ..- U
 - -.. D
 . -.- K
 , .-. R
 [ --- O
 ] ... S
(Note: The letters in the right column is not in use in Morsefuck.)
When you see a code in Morsefuck, you'll get lost: which is its purpose! You don't know where an operator starts and ends because everything is possible from any point of the code!
Morsefuck is supported by a Brainfuck-like languages interpreter implemented by the creator of Morsefuck.
This program shows the famous "Hello World":
 .--..-..-..-..-..-..-..-..-----..--...-..-..-..-..-..-..-..-
 ..-.--...--.-.-.--.--..-.---..---..-.....-..-.--..-..-.--..-
 ..-..----.------...--..-..-..---.--...-..-..-.--...--.--....
 .---..-..-..-..-..-.-.---...--..-..-..--.--.-..-..-..--.-.--
 -..-.---.--...----.-----..-.--..-....--.--...--.-..-..-..-..
 -..-..-..-..-..-..-..-..-..-..-.-.--.---.-..-..-..--.--..-..
 -..-..-..-..-.--..-..-..-..-..-..-..-..-.-.--..--.-.--..--.-
Category:Languages
Category:Joke languages
Category:Implemented
Category:Brainfuck equivalents
Category:2016
Category:Turing complete
Category:Turing tarpits
Category:Low-level
Most ever Brainfuckiest Fuck you Brain fucker Fuck

Most ever Brainfuckiest Fuck you Brain fucker Fuck is a language made by oklopol where you give a system of linear equations in R^n and the base 13 expansion of the supremum of L^2 norms of its solutions is taken as a sequence A, and then you take only the coordinates where the thue morse sequence has a 1 and then you apply the majority CA seven times and then you take the resulting sequence and take the corresponding real number, of whose 27-ary decimal expansion you got, and then you take the standard space filling curve g : [0, 1] \to [0, 1]^2 and you take the function on [0, 1]^2 where (x, y) gets the value f(g^{-1}(z)) where f is the function 7x^4 - 86x + 2 and you take the Lebesque integral over the diagonal with the Lebesgue measure and take its decimal expansion and then you go fuck yourself.
Category:Joke languages