nyuuzyou/wikis huggingface dataset:
Fackward

Fackward is a stack-based esoteric programming language created by User:Koen in 2012. It is an attempt to make a stack-based, but still Turing-Complete, language similar to Fueue, which is queue-based. In Fackward, there is only one data structure. It is made of two stacks, the forward stack and the backward stack. When execution starts, the source of the program is converted to the forward stack. The backward stack is initially empty.
Evaluation proceeds in a way very similar to Fueue:
* Look at the top element of the forward stack.
:* If it is a numeric value, it is popped, converted to a character and printed.
:* If it is a function, and there are enough values of the appropriate type directly behind it in the forward stack, the function and those values are popped, and the result is pushed on top of the backward stack.
:* Otherwise, it is simply popped and pushed back on top of the backward stack.
* If the forward stack is empty, switch the forward and the backward stacks.
* If the two stacks are switched this way twice in a row, without any characters being printed or functions being executed between the two switches, a character is taken from input and its unicode value is pushed on top of the (empty) backward stack.
In practice, Fackward works exactly like Fueue, except the "queue" is read forward and backward.
The only things allowed in a program are nonnegative integers (in base 10), the functions described below, square brackets encoded subprogram blocks, and whitespace.
==Functions==
Function	Effect 	Before 	After
+ 	Adds two numbers 	... +ab... 	...(a+b) ...
- 	Negates a number 	... -a... 	...(-a) ...
* 	Multiplies two numbers 	... *ab... 	...(a*b) ...
/ 	Integer divides two numbers 	... /ab... 	...(a/b) ...
% 	Logically inverts a number (0 to one, n to 0)	... %a... 	...(!a) ...
: 	Duplicates a value 	... :a... 	...aa ...
~ 	Swaps two values 	... ~ab... 	...ba ...
! 	Pops a value 	... !a... 	... ...
$ 	Pushes a number of copies 	... $ab... 	...(a lots of b) ...
( 	Turns a value into a block 	... (a... 	...[a] ...
< 	Adds another value into a block 	... <[foo]b...	...[foob] ...
) 	Deblocks a block 	... )[foo]... 	...foo ...
H 	Halts immediately 	... H... 	
==Examples==
===Cat program/Null program===
As in Fueue, the null program is a cat, although it doesn't handle end of file.
===Hello, world!===
 72 101 108 108 111 44 32 119 111 114 108 100 33 10 H
===Infinite Loop===
 ::
==See also==
* Fueue, which Fackward is merely an ersatz of
* Ftack, a joke language similar to Fackward
Category:Languages
Category:2012
Category:Unknown computational class
Category:Unimplemented
Category:Low-level
Category:Stack-based
FakeC

FakeC is an esolang created by User:None1, it is a brainfuck equivalent. It is made to optimize brainfuck.
==Commands==
FakeC is brainfuck, but every command is replaced with a line of C code.
 Commands in FakeC
brainfuck	FakeC
(begin) 	#include<stdio.h>char tape[1000000];int p;int main(){
+ 	++tape[p];
- 	--tape[p];
, 	tape[p]=getchar();
. 	putchar(tape[p]);
> 	++p;
< 	--p;
[ 	while(tape[p])
] 	}
(end) 	return 0;}
==Examples==
===Cat Program===
#include<stdio.h>
char tape[1000000];
int p;
int main(){
tape[p]=getchar();
while(tape[p]){
putchar(tape[p]);
tape[p]=getchar();
}
return 0;
}
===Hello World===
#include<stdio.h>
char tape[1000000];
int p;
int main(){
++tape[p];
++tape[p];
++tape[p];
++tape[p];
++tape[p];
++tape[p];
++tape[p];
++tape[p];
while(tape[p]){
++p;
++tape[p];
++tape[p];
++tape[p];
++tape[p];
while(tape[p]){
++p;
++tape[p];
++tape[p];
++p;
++tape[p];
++tape[p];
++tape[p];
++p;
++tape[p];
++tape[p];
++tape[p];
++p;
++tape[p];
--p;
--p;
--p;
--p;
--tape[p];
}
++p;
++tape[p];
++p;
++tape[p];
++p;
--tape[p];
++p;
++p;
++tape[p];
while(tape[p]){
--p;
}
--p;
--tape[p];
}
++p;
++p;
putchar(tape[p]);
++p;
--tape[p];
--tape[p];
--tape[p];
putchar(tape[p]);
++tape[p];
++tape[p];
++tape[p];
++tape[p];
++tape[p];
++tape[p];
++tape[p];
putchar(tape[p]);
putchar(tape[p]);
++tape[p];
++tape[p];
++tape[p];
putchar(tape[p]);
++p;
++p;
putchar(tape[p]);
--p;
--tape[p];
putchar(tape[p]);
--p;
putchar(tape[p]);
++tape[p];
++tape[p];
++tape[p];
putchar(tape[p]);
--tape[p];
--tape[p];
--tape[p];
--tape[p];
--tape[p];
--tape[p];
putchar(tape[p]);
--tape[p];
--tape[p];
--tape[p];
--tape[p];
--tape[p];
--tape[p];
--tape[p];
--tape[p];
putchar(tape[p]);
++p;
++p;
++tape[p];
putchar(tape[p]);
++p;
++tape[p];
++tape[p];
putchar(tape[p]);
return 0;
}
==Implementations==
FakeC is unimplemented, but is easy to implement. However, since any FakeC program can also work on C, You can feed a FakeC program to a C compiler, and that will result in an executable equivalent to the original brainfuck program which runs faster than the original brainfuck program. (Note: If you add the -O2 parameter in GCC, it will optimize the code so that a bunch increments and decrements are executed once).
==See also==
* VerboseFuck, similar but much more verbose!
Category:Languages
Category:Brainfuck derivatives
Category:Brainfuck equivalents
Category:Turing complete
Category:Unimplemented
Category:2023
Category:Esoteric subset
FakeScript

FakeScript is an esolang created by User:Viba. The language was meant to be relatively easy to implement for both viba and others who don't know much about programming. FakeScript is quite limited as a result. It was originally written in C#.
The name of the language comes from a Roblox forum post that viba wrote in 2013 when they were 7 years old, containing a program written in a language called FakeScript. Of course, FakeScript didn't become an actual programming language until 8 years later, and the result is very different from the language in the post.
== Overview ==
A program consists of commands followed by arguments (if any). If an argument is #input, it gets the input entered by the user during the previous input command. Each term is separated by a space. Newlines in a program are interpreted as spaces.
== Commands ==
Command 	Description
print [arg1] 	Prints the argument to the console.
input 	Allows the user to enter text as input.
!label [name] 	Declares a label with the specified name.
goto [label] 	Jumps to the label with the specified name.
if [arg1] [arg2] [label]	If arg1 and arg2 are equal, jumps to the label with the specified name.
stop 	Stops the program.
== Examples ==
===Hello, world!===
 print HelloWorld!
Note that since spaces are always used to sepearate terms, strings with spaces cannot be printed.
===Truth machine===
 input
 if #input 1 1
 if #input 0 0
 stop
 !label 0
 print 0
 stop
 !label 1
 print 1
 goto 1
==See also==
* Extension
==External resources==
* Interpreter in Scratch
Category:Languages Category:2021 Category:Finite state automata Category:Implemented Category:Unusable for programming
Fakefuck

Fakefuck looks like Brainfuck but is different.
== Commands ==
 +- pop
 ++ push
 >> to
 << from
 <> swap
 >< seperator
 +. stack
 +, memory
 [[ add
 ][ subtract
 [] divide
 ]] multiply
 [> go to [< if not 0
 [< go to [> if 0
 ]> go to ]<
 ]< nop
 -. 0
 -, 1
 -- user input
 -+ output
== Cat ==
 -->>+,><-++,
== Truth machine ==
 -->>+,><[>><]<><-++,><]>><[<><-++,
== Nop ==
 ]<
Falel

Fancy Assembly Like EsoLang
This is a little thing I made after playing Shenzen I/O.
==Documentation==
Memory Scheme
 | out-buff | in-buff | acc | x3 ... unused ... x255 |
Commands
Command 	Effect
mov R/I R	copy the value of the first arg to the register in second arg
add I 	adds integer to accumulator (wraps around)
sub I 	subtracts integer to accumulator (max 255 min 0)
saz 	Set Accumulator to Zero
fls M 	flushes out-buff to stdout. M(ode) can either be d(ecimal) or c(har)
uib M 	Update Input Buffer, gets a byte of input and stores it in x1
wnz R/I 	While Non Zero
slh 	Stop Loop Here
Full documentation: https://raw.githubusercontent.com/umanochiocciola/falel/main/DOCS
==Examples==
HELLO, WORLD!
add 72; mov acc out; fls c; saz; print H
add 69; mov acc out; fls c; saz
add 76; mov acc out; fls c; saz
add 76; mov acc out; fls c; saz
add 79; mov acc out; fls c; saz
add 44; mov acc out; fls c; saz
add 32; mov acc out; fls c; saz
add 87; mov acc out; fls c; saz
add 79; mov acc out; fls c; saz
add 82; mov acc out; fls c; saz
add 76; mov acc out; fls c; saz
add 68; mov acc out; fls c; saz
add 33; mov acc out; fls c; saz
add 10; mov acc out; fls c; saz
==External Resources==
https://umanochiocciola.github.io/falel/ Front Page
https://github.com/umanochiocciola/falel/tree/main github
FallDown

FallDown is an esolang using "gravity", the main idea is to use balls that can fall, roll, duplicate themselves, mix with other balls, store a value... A FallDown program is executed tick per tick, each tick, all the balls move at the same time. Each ball stores a value (of 0 at beggining) that increase by 1 each tick if the ball is falling.
== Examples ==
=== Basic Example ===
 .
 
 
 
 \ #
 --------
This program output the number 3. Indeed there are 3 lines beetween the start of the ball (.) and the first slope (\), then the ball is falling during 3 ticks (so it has a value of 3 when it arrives at the slope). Then, due to the slope, the ball is going to roll on the groupd (-) until the operand # that print the value stored in the ball. Then the ball will be out of the frame of the program, so the ball will disapear and the execution will be done.
=== Cat program ===
 .
 \? #
 ----
=== Truth Machine ===
 . /
 \? ~#
 ~
 /
 #$-
=== Sum ===
 #
 . .
 \? + ?/
 -------
This program returns the sum of the two inputs (inputs are positives integers)
=== Product ===
 /+ + .
 --- ?/
 /
 $~-~
 
 
 / .
 -~ ?/
 : / / .
 $-\\ -- ---/
 + /
 \-~---~
 #
This program returns the product of the two inputs (inputs are positive integers).
The complexity of the calculation of n times m is linear with n, i.e 𝓞(n) with n the first input.
Category:2024 Category:Two-dimensional languages Category:Implemented Category:Unknown computational class
Falsebrain9Q+Fishload

== Description ==
Falsebrain9Q+fishload is an ingenious combination of many esolangs: False, Brainfuck, HQ9+, Deadfish, and Underload. It has two stacks, a tape, and an accumulator. As you can see, this makes the language Turing-complete but also powerful.
== Commands ==
=== False ===
* {} - execute False code inside {}. 
=== BF ===
* [] - BF loops.
* + - BF increment
* - - BF decrement
* . - BF output
* , - BF input
* < - BF move left
* > - BF move right
=== HQ9+ ===
* H - print Hello, world!
* 9 - print 99 bottles of beer
* Q - perform a Quine
=== Deadfish ===
* i - increment accumulator
* d - decrement
* s - square (using Deadfish arithmetic)
* o - output accumulator
=== Underload ===
* () - execute code inside () as Underload. 
=== Inter-language ===
* %<l1><l2> - transfers data between the two languages' forms of storage.
* Example: %BF pushes the value on the BF tape to the False stack.
==== Language codes ====
* F - False stack
* B - BF tape
* D - Deadfish accumulator
* U - Underload stack
== Examples ==
=== Hello, world! ===
 h
=== 99 bottles of beer ===
 9
=== Quine ===
 q
=== Example ===
This example prints 100.
 iiis%DB+%BF{$*}%FU(S)
First it forms 9 in Deadfish, then adds 1 in BF, then it squares in false, and outputs in Underload.
Category:Languages Category:Turing complete
FantalleFlags

Category:2024
Category:Languages
Category:Turing_complete
Category:Unimplemented
fantalleFlags is a somewhat esoteric language created by User:Cocosbeans in 2024. The language serves as the implementation of logic for cocosbeans' Fantalle project, a text-adventure game implemented similar to Zork I.
= Etymology =
The name fantalleFlags comes from the fact that at the beginning of its implementation, fantalleFlags was intended to be a group of specific, non-Turing complete strings called "flags" that served as data for some objects in Fantalle. However, these strings are now known as "logic".
= Syntax =
fantalleFlags' code is implemented with a custom C++ library, "game_objects.hpp", within the Fantalle project. These strings are grouped in a vector and later accessed and interpreted as logic. Initially, this vector is created when a new object is initialized, like so:
 #include <string>
 #include <vector>
 #include "game_objects.hpp"
 
 Item ExampleItem("Example item name", "Example item description", std::vector<std::string> {"Example item flag vector"});
The syntax of fantalleFlags is inspired by ZIL and Batch, with the former giving way to the full uppercase aspect, and the latter inspiring the sequential reading that the interpreter does.
 { // Example of some logic (snippet truncated)
 "$ EARLY VALF COUNTER 0",
 "$ LATER INTERACT 2",
 "$ JUMPR IFELSEGREATER COUNTER 10 4 5",
 "$ JUMPR VALF COUNTER 0",
 "$ JUMPR MATH ADD COUNTER 1"
 };
This page is a WORK IN PROGRESS. As fantalleFlags implementation extends, so will this page.
Far

Far is a stack-based esoteric programming language designed to have many higher-level functions, yet still take a long time to write simple programs in. All programs are made up of a series of 1 character commands, and most will also use expressions to allow more complex tasks to be written.
== Overview ==
In Far, data can be stored in two places: the stack or a register. The stack is an infinitely-large (bound by memory) series of basic types; there are three registers (R1, R2, and R3) and they can each hold one of each of the basic types.
There are three basic types in Far, which are (almost) the only data structures:
Octet 	A byte
Number 	An integer
Boolean	A truthy/falsey value
Far also supports strings, which are sequences of bytes enclosed in double-quotes. Strings can be stored in registers, but cannot be pushed to the stack.
An if statement uses the syntax
?
 ...
q
(... will only be executed if Stack0 is true)
Functions are declared using a similar syntax of
@<id> <arity>
 ...
q
and then called with
$<id> [args]
Functions share the stack, but have their own registers which are initialised to the arguments passed (argument 1 -> R1, argument 2 -> R2, etc.)
== Commands ==
Command 	Function
p <value> 	Push <value> to the stack
g 	Get the top element of the stack
d 	Delete the top element of the stack
c<n> 	Cycle the top <n> elements of the stack
e 	Empty the stack
s <r> <value>	Set register <r> to <value>
%<r> 	Get the value of register <r>
t <r> <type> 	Set register <r> to type <t>
r <value> 	Return <value> (function only)
q 	Terminate the current block
o 	Write the top element of the stack to STDOUT
i 	Read a line from STDIN (string)
'<char> 	Gets the hex value of <char>. <char> must be a printable ASCII character
l 	Declare a label
j 	Jump to the most recent label
! 	Returns NOT Stack0
& 	Returns Stack0 AND Stack1
 	Returns Stack0 OR Stack1
^ 	Returns Stack0 XOR Stack1
= 	Returns true if Stack0 equals Stack1, false otherwise
+ 	Returns Stack0 + Stack1
- 	Returns Stack1 - Stack0
Any unrecognised character should be ignored.
== Examples ==
===Hello, World!===
This program prints the string "Hello, world!"
p '!
p 'd
p 'l
p 'r
p 'o
p 'W
p x20
p ',
p 'o
p 'l
p 'l
p 'e
p 'H
ododododododododododododod
It is possible to write a print function, but doing so would take longer than manually pushing the string.
=== Print function ===
@1 1
	s R2 0
	l1
	p :%R2%R1
	o
	d
	p %R2
	p 1
	s R2 +
	d
	d
	p X00
	p :%R2%R1
	p =
	p !
	?
		d
		d
		d
		d
		j1
	q
	d
	d
	d
	d
	p X0A
	o
	d
q
== External resources ==
* Far Specification
* Reference implementation
Category:Languages Category:2018 Category:Turing complete Category:Implemented
Fargo

Fargo (Function argument-o) is an esolang created by User:PythonshellDebugwindow.
==Overview==
Fargo is a functional esolang. Each line is either a function definition, a function call, a blank line, or a comment.
==Memory==
Fargo uses an input number, an integer which is defined by the interpreter (typically to be a user-input number) before the program begins. It also uses an output number, which can be output at any time in the program.
==Syntax==
===Function calls===
A function can be called by typing its name followed by a space, then its (space-separated) arguments, which are evaluated from left to right.
===Function definitions===
Function definitions are rather unorthodox in Fargo. Each definition takes up exactly one line (excluding comments). The first token of a function definition is its name (redefining an existent function is an error); the rest of the tokens are its arguments and its code. The divide between arguments and code is fairly unusual: the first defined name is the first code token, and the previous token is the final argument. Defined names are built-in functions, user-defined functions (including the function being defined), and the arguments of the function currently being defined.
Functions must contain exactly one outer function call (e.g., myFn x y z otherFn x thirdFn ​y z is legal while myFn x y z otherFn x y z anotherFn x and myFn are not; even though the first example calls thirdFn, it doesn't do so at the top level).
===Colons===
If a token begins with a : colon, it either represents a raw function (as opposed to a function call), which can be used as an argument to a function, if it is not a function argument; or marks a function argument as being a raw function, rather than a value.
===Literals===
Literals are binary integers matching the regex /[0-1]+/.
===Comments===
Comments are declared by using #, and last until the end of the line.
==Built-in functions==
* < x returns x right-shifted by 1
* > x returns x left-shifted by 1
* & x y returns x bitwise-AND y
* | x y returns x bitwise-OR y
* ^ x y returns x bitwise-XOR y
* [] x returns an array with only x in it
* +[] x y returns the array x concatenated with the array y
* [?] x y returns the yth element of the array x
* @ x returns the xth bit of the input number (LSB = 0th bit)
* % x y sets the xth bit of the output number to y (LSB = 0th bit)
* $ outputs the output number in base-10
* : x y does y iff x is unequal to zero
==Examples==
===Truth-machine===
 one ​^ $ one
 ​% 0 @ 0
 : @ 0 one
 $
Category:Languages Category:2020 Category:Unimplemented Category:Functional paradigm Category:Unknown computational class
Farnsworth

Farnsworth is an interpreted toy language created by Ryan Voots (simcop) in 2010. One of its uses was to convert between measurement units and currencies in IRC using an IRC bot that evaluates Farnsworth expressions, but the language kept growing from there. The implementation is in perl.
Farnsworth has built-in dimensioned numbers (numbers possibly multiplied by powers of primitive measurement units like meter or second). There are primitive and derived units defined by the standard library, but you can also define new primitive units. SI prefixes like kilo are parsed even when prefixed to a unit without any separator, eg. you can write attoparsecs and Farnsworth will know that that's the product of the prefix atto with the unit parsecs. Farnsworth has built-in first-class functions, arrays, dates.
A notable syntactic feature of the language is that you can juxtapose two expressions without anything between to either call a first-class function with a single argument or multiply two numbers. The latter is needed to conveniently write numbers with measurement units. Postcircumfix square brackets are used to call functions with any arity, sort of like in Mathematica. You can, in fact, also call first-class functions of a single argument with an explicit multiplication operator *.
== Links ==
* Documentation of the language, as well as interpreter download: CPAN distribution Language-Farnsworth
Category:Languages
Category:Implemented
Category:2010
Category:Turing complete
Category:High-level
FastBrain

It is made because of one of the weaknesses in bf: Moving to another cell in the tape is slow.
==Tape==
Instead of a 1D tape, FastBrain has a 15D tape.
==Commands==
< - Move the tape to the left
> - Move the tape to the right
^ - Move the tape to the up
V - Move the tape to the down
a - Move the tape to the positive 3D direction
b - Move the tape to the negative 3D direction
c - Move the tape to the positive 4D direction
d - Move the tape to the negative 4D direction
e - Move the tape to the positive 5D direction
f - Move the tape to the negative 5D direction
g - Move the tape to the positive 6D direction
h - Move the tape to the negative 6D direction
i - Move the tape to the positive 7D direction
j - Move the tape to the negative 7D direction
k - Move the tape to the positive 8D direction
l - Move the tape to the negative 8D direction
m - Move the tape to the positive 9D direction
n - Move the tape to the negative 9D direction
o - Move the tape to the positive 10D direction
p - Move the tape to the negative 10D direction
q - Move the tape to the positive 11D direction
r - Move the tape to the negative 11D direction
s - Move the tape to the positive 12D direction
t - Move the tape to the negative 12D direction
u - Move the tape to the positive 13D direction
v - Move the tape to the negative 13D direction
w - Move the tape to the positive 14D direction
x - Move the tape to the negative 14D direction
y - Move the tape to the positive 15D direction
z - Move the tape to the negative 15D direction
+ - , . [ ] - The same as bf
As such, by arranging the cells smartly, the pointer only has to move at most 15 times to move to another cell even if you use 32768 cells.
</pre>
==Examples==
Not yet...
==Interpreters==
Not yet...
Category:Languages
Category:2024
Category:Brainfuck derivatives
Fb

It is BF but when executed, the characters are rearranged in random order first.
==Examples==
===Cat program===
 [],.,
Of the 60 possible programs to be executed when this program is passed, only ,[.,] cats correctly, as such, this program has a probability of 1/60 to cat.
==Interpreters==
===Python===
import sys,random
def bf(code):
 s=[]
 matches={}
 tape=[0]*1000000
 for i,j in enumerate(code):
 if j=='[':
 s.append(i)
 if j==']':
 m=s.pop()
 matches[m]=i
 matches[i]=m
 cp=0
 p=0
 while cp<len(code):
 if code[cp]=='+':
 tape[p]=(tape[p]+1)%256
 if code[cp]=='-':
 tape[p]=(tape[p]-1)%256
 if code[cp]==',':
 c=sys.stdin.read(1)
 tape[p]=(ord(c) if c else 0)%256
 if code[cp]=='.':
 print(chr(tape[p]),end=)
 if code[cp]=='<':
 p-=1
 if code[cp]=='>':
 p+=1
 if code[cp]=='[':
 if not tape[p]:
 cp=matches[cp]
 if code[cp]==']':
 if tape[p]:
 cp=matches[cp]
 cp+=1
k=list(input())
random.shuffle(k)
bf(.join(k))
Category:Languages
Category:Joke languages
Category:Nondeterministic
Category:2024
Category:Brainfuck derivatives
Category:Implemented
Fear

Fear is an esoteric programming language that gives you esolangaphobia.
It has six instructions: i, o, +, -, j and r.
== Instructions ==
It has one variable.
i takes input from the user and sets the variable to the first character of what they have written. If they haven't written anything then the variable is set to ' ' (a space).
o prints the variable.
+ shifts the variable forwards to the next ASCII value. For example 'a' becomes 'b' and 'z' becomes '{'.
- does the opposite.
j jumps to the beginning of the program.
r resets the variable to ' '.
== Examples ==
=== Cat program ===
 ioj
=== Caesar shift by 4 ===
 i++++oj
=== Shortest infinite loop ===
 j
=== Hello world ===
 ++++++++++++++++++++++++++++++++++++++++o---o+++++++oo+++o
=== Spam console with #s ===
 +++orj
== Implementations ==
* An implementation in R7RS Scheme by User:OrichalcumCosmonaut: via HTTPS or [gemini://tilde.team/~orichalcumcosmonaut/darcs/esolangs/fear-in-scheme/ via Gemini].
Category:Languages
Category:Unknown computational class
Category:Usability unknown
Category:Implemented