nyuuzyou/wikis huggingface dataset:
Formula

Formula is an esoteric programming language created by User:ais523 in 2006 as an exploration of the boundaries of the wire-crossing problem.
==Syntax==
A Formula program consists of a mathematical formula in one or more unknowns that evaluates to a real number; for instance, xy is a valid Formula program. Subscripts can be used on variables so there is an infinite stock available. The following mathematical operations are supported:
*Addition
*Subtraction
*Multiplication
*Division
*Exponentiation
*Sin, cos, tan (in radians) and their inverses
==Semantics==
Each variable in the formula corresponds to a variable in the program; all variables initially start at 0. Although the output of the formula merely has to be a real number, the variables are always integers. The formula is evaluated, and the output interpreted as follows:
*If the output is an integer + ½ exactly, a bit is read from input, and it is rounded up to the nearest integer if the bit is 1 or down to the nearest integer if the bit is 0; then one of the following actions is applied to the rounded result.
*If the output is 0 exactly, the program ends.
*If the output is in the range (-½,½), then a 0 bit is output (if the output was negative) or a 1 bit is output (if the output was positive), and the first variable name is decremented or incremented (according to the sign of the result).
*If none of the above apply, the output is rounded to the nearest integer; if the result is a positive integer n, the nth variable is incremented, and if it's a negative integer -n, the nth variable is decremented.
*It is an error if the result refers to a non-existent variable (otherwise, the program would simply go into a trivial infinite loop).
This evaluation and interpretation of the result is repeated until the program ends.
==Interpretation of the language==
There are two ways to interpret the language; either as a zero-dimensional language with the variables as data storage, or as a multidimensional language with each variable corresponding to a dimension. For instance, a two-variable program has no wire crossings in its state diagram, which is trivial to prove by plotting each possible state of the program at (x,y) for a program with variables x and y.
==Computational class==
With three variables Formula can reasonably simply simulate a Minsky machine, and so is Turing complete. The computational class with two variables is unknown. All one-variable programs cannot go into a non-infinite loop and so cannot even emulate a push-down automaton.
Category:Low-level
Category:Unimplemented
Category:Zero-dimensional
Category:Multi-dimensional languages
Category:Turing complete
Category:2006
Forth

Forth is a stack-based language invented by Charles H. Moore in the 1970s. Although designed for hardware control, interactive programming, and writing applications; it is itself somewhat esoteric compared to other mainstream languages. Its very simple syntax and operandless computational model allow it to have very compact implementations. It has inspired many other stack-based esoteric languages, such as FALSE and Befunge.
Many things from other programming languages (both esoteric and normal) could already be done in Forth a long time ago, such as making up your own control structures. Now there are many Forth standards and many Forth implementations which either follow the standards or don't follow the standards. Forth is a very powerful program language because whatever it is missing you can add it in by yourself!
==colorForth==
Chuck Moore went on to refine his own Forth programming environment, gaining inspiration from his own custom microprocessor designs. The result is colorForth, which looks even more esoteric than standard Forth. For more compact programs and to assist his failing eyesight, the language uses color to distinguish syntactic elements of the language. From his own :
*Stand-alone! Includes operating system.
*Compact! 2K bytes for core software.
*Fast! Optimized object code.
*Simple! Applications stored as source. No object library.
*Innovative! Text compressed and pre-parsed.
*Unique! 27-key Dvorak keyboard.
==Machine Forth==
Chuck Moore also uses a pared down Forth for his custom minimal-instruction set processors. They are an inspiration for designing other minimal languages. For example, his latest designs have five-bit instructions, for 32 possible opcodes:
* Stack: DROP, DUP, OVER, PUSH, POP
* Math: +, AND, XOR, NOT, 2*, 2/, multiply-step
* Call: JUMP, CALL, RETURN, IF, -IF
* Loop: NEXT, UNEXT
* Register: A, A!, B!
* Memory: @, !, @+, !+, @B, !B, @P, !P
* NO-OP: .
==External resources==
*Forth at Wikipedia
*
*
*
*learnxinyminutes: Forth
*Forth Interest Group
Category:Languages
Category:Implemented
Category:Stack-based
Category:Meta-languages
Category:Before 1993
Fortuna

Fortuna is an esoteric programming language inspired by Brainfuck. Its mechanisms are based around the idea of a wheel, making Fortuna a turning tarpit.
Fortuna is a language in which there is a theoretical wheel, spinning at a constant speed of 1, that manipulates a set of bits. On this wheel there are five commands:
 0 Switch current bit's value
 1 Move bit pointer in current direction
 2 Scan (searches in current direction for a scan in the opposite direction
 with wheel spinning, but not executing anything except directional changes,
 and not changing the direction of the search)
 3 I/O out (right) in (left) big-endian storage
 4 Switch direction of wheel
Scans can be nested. The actual code is expressed in 0's and 1's:
 0 Change nothing
 1 Take hand on or off the wheel
The language starts with hand off and going right. This program outputs a beep (the bell character, ASCII code 7):
 01100011 00011000 11001010 01010010
 10011001 00110001 10001100 01100011
 00011000 11001100
==See also==
* Whirl
Category:Languages
Category:Unimplemented
Category:Turning tarpits
Category:Brainfuck derivatives
Category:Unknown year
Category:Unknown computational class
Forþ

Forþ is a stack based language.
==Commands==
Name 	Function
0-F 	Add that number to stack.
: 	Duplicate top.
+-*/%	Do the obvious operation (top goes on right).
~ 	Bitwise not the top
. 	Output the top as unicode.
, 	Take string input and store it's unicode values in the top (right goes on top).
() 	If the top is not 0
[] 	While the top is not 0
{} 	Store a function in the number atop the stack.
; 	Call the function stored by the stack.
o 	Reverse the stack.
c 	Rotate the top 3 elements.
v 	Swap the top 2 elements.
==Examples==
===Cat program===
 1{,0o[.]1+}[;]
===Hello, world!===
 0F2*3+F6*A+F7*3+F7*9+F7*6+F7*E+F2*2+F2*E+F7*6+F7*3+F7*3+F6*B+F4*C+[.]
==Implementations==
A C++ interpreter by User:Bangyen.
Category:Languages
Category:2022
Category:Stack-based
Category:Unknown computational class
Category:Implemented
Category:Functional paradigm
Four

Four is an esoteric, purely functional programming language.
* Only has three characters, all others are ignored: `4()`
* Operations are contained within parentheses, the first contained expression is the type. e.g. `(44(444))`
* `()` is Nil.
== Examples ==
This is a simple program that outputs "Hello, world!" It's minimally optimized, and could almost certainly be made much smaller.
(4((4444444)(4(444)(((444)44)4(((444)44)44))))((4444444)(4(((444)44)(44444)(44((444)(444)4)))(44((444)44))))(((444)44)((4444444)(4(((444)44)(44444)(44((444)(444)4)))(4444)))((444)(444)4))((4444444)((((444)44)44)(((444)44)4(444444444))(4(44444)((444)44))))((4444444)(4(444444444)(4444)))((4444444)(444444444))((4444444)((((444)44)44)(((444)44)4(444444444))(4(444)((444)44))))((4444444)((((444)44)44)(((444)44)4(444444444))(4(44444)((444)44))))((4444444)((((444)44)44)(((444)44)4(444444444))(4(4444)((444)(444)4))))((4444444)(4(((444)44)(44444)(44((444)(444)4)))(4444)))((4444444)(((444)44)4(4(4444444)((444)44))))((4444444)(4((444)44)(444444444))))
== Value Types ==
Four supports the following data types:
* Integer: Non-fractional numbers, created using the `4` literal or from various operations.
* Nil: A type representing nothing, created using the `()` literal.
* String: A string of 0 or more Unicode characters, created using "char code to string" and other operations.
* Function: A callable procedure, created using "function declaration". Usable as an operation.
== Operations ==
ID 	Operation 	Description
0 	function declaration 	Takes one expression as a parameter, and returns a callable function form of it. Functions can be used as operations.
1 	multiply 	Takes any number of values and multiplies them, ignoring nils. If passed zero values, returns nil. Strings can be multiplied by integers for repetition.
4 	add 	Takes any number of values and adds or concatenates them, ignoring nils. If passed zero values, returns nil.
8 	divide 	Divides two numbers. If either value is nil, returns nil.
9 	character from string	Takes a string and an integer, returns the character at the given index in the given string as a string.
12 	conditional 	Takes three values. If the first value is 4, the second is returned, otherwise the third is returned.
16 	subtract 	Subtracts two numbers. If either value is nil, returns nil.
24 	char code to string 	Interprets a number as a Unicode codepoint. Returns a string.
nil	get 	Returns a function parameter by index.
Category:Functional paradigm Category:2018 Category:Implemented Category:Unknown computational class
FourQueue/Interpreter.py

:
 from collections import deque
 import sys, re, random, argparse
 
 def Err44():
 sys.stderr.write("ERROR 44")
 sys.exit(1)
 
 def FourQueue(prgm, inp, no_prng, any_ints):
 if not any_ints and not re.search('^[4 ]*$', prgm):
 Err44()
 
 numQueue = deque()
 progStack = [*map(int, prgm.split())][::-1]
 
 if no_prng:
 x, y = 7, 8
 else:
 x = random.randint(7, 99)
 y = random.randint(7, 99)
 while x == y or x == 44 or y == 44:
 x = random.randint(7, 99)
 y = random.randint(7, 99)
 
 while progStack:
 cmd = progStack.pop()
 if cmd == 0:
 sys.exit(0)
 elif cmd == 1:
 if len(numQueue) < 2: Err44()
 a = numQueue.popleft()
 b = numQueue.popleft()
 numQueue.append(a + b)
 elif cmd == 2:
 if len(numQueue) < 2: Err44()
 a = numQueue.popleft()
 b = numQueue.popleft()
 numQueue.append(a - b)
 elif cmd == 3:
 if len(numQueue) < 2: Err44()
 a = numQueue.popleft()
 b = numQueue.popleft()
 numQueue.append(a * b)
 elif cmd == 4:
 if len(numQueue) < 2: Err44()
 a = numQueue.popleft()
 b = numQueue.popleft()
 if b != 0:
 numQueue.append(a // b)
 else:
 progStack.append(a)
 elif cmd == 5:
 if len(numQueue) == 0: Err44()
 a = numQueue.popleft()
 if a not in range(0x110000): Err44()
 print(chr(a), end='')
 elif cmd == 6:
 if inp:
 numQueue.append(ord(inp[0]))
 inp = inp[1:]
 else:
 numQueue.append(-1)
 elif cmd == x:
 if len(numQueue) == 0: Err44()
 a = numQueue.popleft()
 seq = []
 if len(numQueue) < a: Err44()
 for i in range(a):
 seq.append(numQueue.popleft())
 progStack.extend(seq[::-1])
 elif cmd == y:
 if len(numQueue) < 2: Err44()
 a = numQueue.popleft()
 b = numQueue.popleft()
 seq = []
 if len(numQueue) < a: Err44()
 for i in range(a):
 seq.append(numQueue.popleft())
 for i in range(b):
 for n in seq:
 numQueue.append(n)
 elif re.search('^44+$', str(cmd)):
 numQueue.append(cmd // 10)
 else:
 numQueue.append(cmd)
 
 salt = ['fjords', 'jawbox', 'phlegm', 'qiviut', 'zincky']
 random.shuffle(salt)
 opt1 = '--no-prng-' + '-'.join(salt)
 random.shuffle(salt)
 opt2 = '--any-ints-' + '-'.join(salt)
 
 try:
 parser = argparse.ArgumentParser(description='Run a FourQueue program')
 parser.add_argument('progtorun', metavar='progtorun', type=str,
 help='the filename of the FourQueue program to run')
 parser.add_argument(opt1, dest='no_prng', action='store_true',
 help='guarantee x=7 and y=8')
 parser.add_argument(opt2, dest='any_ints', action='store_true',
 help='allow any integers in the source code')
 args = parser.parse_args()
 
 f = open(args.progtorun)
 prgm = f.read()
 f.close()
 inp = input('Input: ')
 FourQueue(prgm, inp, args.no_prng, args.any_ints)
 except IOError:
 sys.stderr.write("Error: Can't open file '%s'" % args.progtorun)
 sys.exit(1)
Category:Implementations
Fourfuck

Fourfuck is an incomplete language created by Lesidhetree that was originally intended to be very loosely based on Brainfuck. Its name comes from the fact that its core commands (originally all commands) that, including the arguments, are four characters. Interestingly, the word most often said aloud by the author shares a spelling with the last four letters of the language's name.
It was created with the goal of programming an Arduino Uno from data on an SD card, though, after the subsequent modifications that were needed to complete that goal, it no longer has anything in common with the Brainfuck language.
To avoid unneeded obscenities in the code and documentation, the language is sometimes referred to by the code name "4FK".
For reasons the author has not yet decided on, each implementation has been named after a Cephalopod. For example, before the separation of language and interpreter development, the Arduino sketch that interpreted the code was "Octopus". (Final version of that incarnation of the interpreter was code-named "Octopus 0006")
Starting with language version "4FK v0.1-alpha-0006-201506012337", the language began to be divided into core commands and extension commands.
==Operators==
A description of the core command-argument blocks used in the cat example are described below:
Syntax	Description
[11= 	While the contents of variable "C[1]" equal the contents of variable "C[1]"
]11= 	End "While (C[1] == C[1])" from above
A120 	Store the hex value 0x20 into C[1]
SIB0 	Store the next char inputted from the terminal into C[0]
SOB0 	Output the char stored in C[0] to the terminal
===Variables===
Variables are stored in one of two arrays of unsigned char values (byte values):
C[] array (32 elements)
T[] array (256 elements)
==Example programs==
===Cat program===
 A120[11=SIB0S0B0]11=
==Implementation==
If I make an implementation in C or C++, i will link to it.
==See also==
* Brainfuck
Category:Languages
Category:Brainfuck derivatives
Category:Unknown computational class
Category:Cell-based
Category:Low-level
Category:Unimplemented
Category:2015
Frackit

Frackit is an esolang created by islptng. It operates on fractions. It has a stack.
== Commands ==
Command	Meaning
#n 	push(n) (n is a positive integer)
/ 	push(1/pop())
! 	pop()
< 	insert(0,pop())
> 	push(pop(0))
^ 	push(pop().denominator)
* 	push(pop()*pop())
: 	duplicate top of stack
% 	swap top 2 items
[code] 	execute code infinitely
code2) 	pop, if equal to 1, execute code1, else execute code2
+ 	continue
- 	break
, 	input a number(can be fraction or integer), push it
. 	pop a value and print it(as fraction or integer)
'c 	print c as a character
If the program begins with a number, the I/O will be modified to the number-base.
For example, if the program begins with 2, inputting 16 will cause 65536 to be pushed(2^16=65536); outputting 65536 will cause 16 to be printed.
== Examples ==
=== Hello World ===
 'H'e'l'l'o',' 'w'o'r'l'd'!'
=== Truth Machine ===
 ,(['1]|'0)
=== Cat ===
There's no current Cat Programs, since this language only allows you to input an any fraction, so the below one is actually a fraction cat.
 [,.]
=== XKCD Random Number ===
 #4.
Alternative:
 '4
=== A+B problem ===
 2,,*.
It supports any positive integers.
== Interpreter ==
Try it online!
Fractaler

fractaler is a thing that uses fractals to code
== instructions ==
 X -> A, B... [condition] - X splits into A and B... only if condition
 X -< A - X has a value A
 - X - count number of X
 > X (A,B,C...) places X, with maybe the values being ABC...
== fixed cat ==
 X -< A
 X:A -> X:(A:(A-1)) [X:A>1]
 > X A:5
 - X #should be 5
== out:a=((out:a-1)*2)+1 ==
 X -< A
 Y -< B
 X:A -> X:(A:(A-1)) [X:A>1], Y:(B:(A-1))
 Y:B -> X:B [Y:B>1]
 > X A:5
 - Y #should be 31
Fragile

Fragile is a family of families of programming languages theorized by User:Otesunki.
Fragile consists of families of programming languages, each programming language being called Fragile-N, where N is a natural number.
Fragile-N is a family of turing complete programming languages (each can be identified with a name, all of their source codes are in the form of a list of numbers) consisting of N instructions (and a data structure of choice), where getting rid of any one instruction causes the programming language to stop being turing complete.
an instruction is an (ideally simple) operation that changes the instruction pointer, and alters the data structure of choice.
Category:Languages Category:Turing complete
FrainBuck--

FrainBuck-- is a 2-dimemsional programming language created by User:Xi-816. It's a BrainFuck derivative, but it has only 4 commands.
Command	Description
+ 	Add 1 to current cell, then modulo 256
: 	If current cell's value is even, change direction's pointer to left, and go to next cell, else, change direction's pointer to right, and go to previous cell
~ 	Turn right
$ 	Output as an ASCII character
Category:Languages Category:Two-dimensional languages Category:Cell-based Category:Output only Category:Brainfuck derivatives
FrancePROG

FrancePROG is a french half-assisting programming tool (develops itself your ideas), that can only be opened in Microsoft Windows computers because of the fact that it's written in Batch. It is designed to be easy to understand, and having a totally familiar language, even if some words are more complex and mathematics-based. The syntax looks mostly like a programming language, and thus, he has a place in the programming world.
== Syntax ==
* CTRL+E: writes.
* CTRL+P: pauses the programm.
* CTRL+V: defines a variable.
* CTRL+C: defines a counting variable.
* CTRL+D: asks the player a variable.
* CTRL+I: insert an .bmp image.
* CTRL+A: calls another programm, also opens another file.
* CTRL+H: displays the help banner.
* INSER: begins the programm.
* CTRL+S: equals any other language's "if".
* DEL: deletes the programm.
* F11: creates a label.
* F12: goes to a label.
* CTRL+N: clears the programm's window.
== Samples ==
Samples were taken from "log.html" after programming it.
=== Hello world ===
 Alors en gros, on va commencer un programme.
 Ce serait bien si on écrivait «Hello, world!».
 Après, on arrête le programme un instant! C'est bien ça.
Category:Languages Category:High-level Category:2015 Category:Implemented Category:Pseudonatural
FreakC

FreakC is a clone of Batch and also compiles into Batch codes as well. There is nothing to say about the language really as it is the same as Batch (you can also writes Batch in it), but it adds drunk commands and memes, brainless quotes or "straight-up everyday swearing". Also, most of the commands are direct equivalents to those in Batch, but you know, got turned into swearing. The language is merely hurtful to write as it is just Batch scripting with "bad words" and no "fun" rules added like Intercal or Trumpscript. Technically, if you want to write Batch but you hate humans' existence and wonder wtf are you doing, then hell yeah if this language's good for you. For more info go to https://github.com/nguyenphuminh/FreakC.
==Example==
This is a Hello, World! program written in FreakC:
 Swear[fnc] Hello, World^!
As you can see, nothing too scary about it compares to other esolangs.
You can also prints out random numbers endlessly lIke A hAckeR using:
 CoolHackerMan[fnc]
P/S: If you have read the language's documentation and feel offended by the language's syntax, I'm really sorry.
Category:Languages
Category:Turing complete
Fringespeak

Fringespeak is an interpreted scripting language, whose original interpreter was implemented using YoyoGames' GameMaker Language (GML). It is created for the Fringes of the Empire game produced by Indie game developer Lost Astronaut. One of two languages developed by the company. Fringespeak has rudimentary objects, implicit structures like lists, objects and properties, and global variables. It lets you develop a 2D space shooter game by inserting plot and even making simple on-screen animations by using lookup tables to select from pre-loaded graphics and sound.
==External resources==
* Lost Astronaut Studios Website
* Language specification
* GML Pro Pack that includes some of the language implementation
Category:ImplementedCategory:2014Category:Languages
Frog

Frog is an esoteric programming language created by Stysan (talk) that commands are based on sounds that frogs make. Syntax of this language is based on Batch syntax. Frog scripts extension is .frgp. There's also another language called Sickfrog - which is sick (in the bad meaning) version of Frog.
 Commands
Example 	Output 	Description
croak Hello World! 	Hello World! 	Outputs a value.
quack How old are you?	How old are you?	Asks a question.
ribbit 14 	No output 	What question answer should be.
bark 	True/False 	Checks if answer is right.
beep 10 	1-10 	Outputs a random number between 1 and entered value.
cluck 1 	No output 	Sleeps value seconds.
*something 	No output 	Comments.
== Interpreter ==
This is the original interpreter for Frog written on Python 3.8.5.
 from tkinter import Tk, filedialog as fd
 from time import sleep
 from random import randint
 
 tk = Tk()
 tk.withdraw()
 
 filetypes = [("Frog Scripts", "*.frgp"), ("All files", "*.*")]
 code = fd.askopenfilename(title="Select a Script", filetypes=filetypes)
 code = open(code, mode="r")
 code = code.read()
 code = code.split("\n")
 
 answer = ""
 answer_shouldBe = ""
 
 def bug():
 print("ERROR")
 sleep(1)
 quit()
 
 for i in code:
 try:
 if i.startswith("croak "): print(i[6:])
 elif i.startswith("quack "): answer = input(i[6:])
 elif i.startswith("ribbit "): answer_shouldBe = i[7:]
 elif i == "bark": print(answer == answer_shouldBe)
 elif i.startswith("beep "): print(randint(1, int(i[5:])))
 elif i.startswith("cluck "): sleep(int(i[6:]))
 elif i == "" or i.startswith("*"): pass
 else: bug()
 except: bug()
== Examples ==
Hello World!
 croak Hello World!
 Quiz! 
 croak Quiz!
 ribbit esolangs.org
 quack What is the best site about esolangs?
 bark
 croak I won't add more questions I'm lazy
== See also ==
* Ook!
* Sickfrog
Category:Languages Category:Implemented Category:Unusable for programming Category:Total Category:Thematic
From INTERCAL to LOLCODE: The Esoteric Programming Story

From INTERCAL to LOLCODE: The Esoteric Programming Story is a concept documentary from User:Star651 in 2012. No filming has been done yet, but the concept is down.
==Concept==
Just as documentaries about text adventure games, Wikipedia, ASCII-based bulletin board system communication, the lives of musicians, and much more have been done, this would be a documentary about the very underground esoteric programming scene, starting with the prehistory, then focusing more heavily on INTERCAL, the first esolang to be called an esolang. Then the humorous Info World article from the 1980s will be covered, then the infamous languages of the 1990s. Then, the topic of internet-based creation of esolangs will come up, with the mailing lists and forums, eventually making our way to this very wiki. Things such as the Essies will be covered, and, as the title suggests, everything from the old language INTERCAL to the modern-day esolang LOLCODE. Hopefully many interviews will be done, and those clips will be in the movie.
==Stretching the concept==
Any potential movie directors, producers, interviewers, interviewees, etc. can post on this article's talk page.
Category:Concepts