nyuuzyou/wikis huggingface dataset:
Five

Five ia an esoteric programming language created by Andrew Bayly in 2023. 
Five is a OISC. The one instruction has one parameter, meaning that the syntax for Five is nothing more that a sequence of integers which are references to memory cells.
== Opcode ==
 Opcodes
Opcode	parameters	action
n/a 	a 	retrieve bit from memory cell a, and bit from register q. Combine with NAND. Write result back to a and back to q.
== Implicit loop ==
There is no explicit loop construct in Five. Rather, the sequence of instructions repeats continuously until it is instructed to halt.
== Input/Output ==
At the end of the loop (subject to change?), the check-bits are checked. If Input is checked, then a single 16-bit value is read into the input byte (and Input is cleared). If Output is checked, then a single byte is written out from the Output byte (and Output is cleared). If Halt is checked, then the program halts, otherwise it loops back to the start.
=== Memory Mapping ===
== Syntax ==
Comments are allowed in Five. On each line, everything following the first ; is ignored.
Otherwise, Five syntax consists only of a sequence of integers separated by space. Each integer is an instruction where the integer is the value of parameter a.
== Example programs ==
TODO:
Category:Languages Category:OISC Category:Finite state automata Category:Cell-based
Fixed Repeating Output

Code that repeats a fixed amount of times given from input, while repeating, output 1, then output 0 after the loop is done.
This shows that the esolang can support fixed loops, and I/O.
For example, if you input 5, then it'll output this.
 1
 1
 1
 1
 1
 0
or, depending on the esolang, it'll probably output this instead.
 111110
==Implementations==
===:]===
 :) :|
 :]] :)
 :0 1
 :[[
 :0 0
===brainfuck===
[-]>[-]+[[-]>[-],[+[-----------[>[-]++++++[<------>-]<--<<[->>++++++++++<<]>>[-<<+>>]<+>]]]<]>>>>>>>>>>>>>>[-]<<<<<<<<<<<<<<<[>>>>>>>>>>>>>>>+<<<<<<<<<<<<<<<-]>>>>>>>>>>>>>>>[<<<<<<<<<<<<<<<[-]++++[>++++++++++<-]>+++++++++[<+>-]<.[-][-]++++++++++.[-]>>>>>>>>>>>>>>>-]<<<<<<<<<<<<<<<[-]++++[>++++++++++<-]>++++++++[<+>-]<.[-]
Source code, in BFFuck:
 x=in
 while(x)
 outc(49)
 outc(10)
 sub(x,1)
 endwhile
 outc(48)
Another one which support bignums:
>,[<------[+>--------<]>>>[<<[->+<]>>->[>]>[>]+>+>+>+>+>+>+>+>+>+[<]<[<]>]<<[->+<]>[->[>]+[<]<],]<++++++[->++++++++<]>>>[<<[->+>+<<]>>.[-]>]<<.
there is a counter stored as unary on the tape, every time a digit is entered counter *=10, and each unary digit is added by 48 to produce the output.
===Brainfuck+2===
 ';[>+:-<-]>:
===How dare you fuck the brain===
 ;^Iv
 D^Nv)NH
===Iterate===
(*)1<
 *?<
 *1< @ >
 >
 (1*)48<
 *~n< &1 >
 ~@
 >
>
===MoreMathRPN===
 inputR
 repeat ]0
 outputS "1"
 next
 outputS "0"
===STRong===
Input is in unary
pa`
:0:digit
'a'?
.loop
'{p}~;digit'<1>
'p~`'<0>
^p^loop
==External Resources==
* Codegolf Stack Exchange solutions
Category:Program forms
FixxBuxx

FixxBuxx is a joke language. It is used for writing FizzBuzz Programmes, but you can write other programmes too!
== Commands ==
Command 	Description
Fimultiple1Bumultiple2	Changes the standard multiples for activating the “Fizz”, “Buzz”, and “FizzBuzz” outputs to the integer multiple1 for “Fizz” and the integer multiple2 for “Buzz”. “FizzBuzz” is computed using the least common multiple (lcm) in this mode: lcm(integer1, integer2).</code>
Fizz -> string 	Sets the string to print for multiples of “Fizz” to string.
Buzz -> string 	Sets the string to print for multiples of “Buzz” to string.
FizzBuzz -> string 	Sets the string to print for multiples of “FizzBuzz” to string.
range(start, end) 	Sets the loop counter start value to the integer start and its inclusive end value to end, which might be an integer or the inf constant for an infinite repetition.
when(counter)string 	Associates the string with the integer counter. If the program loop counter matches the counter, the string is printed instead of the usual message. This behavior overwrites all other output, including “Fizz”, “Buzz”, “FizzBuzz”, and the verbatim counter printing.
if(counter){code} 	Associates the code with the integer counter. If the program loop counter matches the counter, the zero or more commands of the code are executed.
in 	Queries the input conduit for an integer value, admissible in any position which accepts integer literals.
)annotation 	Inserts the commentary annotation text into the code.
== Examples ==
=== Hello, World! ===
 range(1,1) ) The range is from 1 to 1
 when(1)Hello, World! ) When you need to print 1, print "Hello, World!" instead.
 Fi1Bu1 ) Multiples of 1(Only 1), print "FizzBuzz". But you need to print "Hello, World!" because of the "when" command.
=== FizzBuzz ===
 Fi3Bu5 ) Multiples of 3 are replaced with "Fizz", and multiples of 5 are replaced with "Buzz". Multiples of lcm(3,5) = 15 are replaced with "FizzBuzz".
=== Truth Machine ===
 range(in,1) ) If input is 0, the range is from 0 to 0. If input is 1, the range is from 1 to 1
 Fizz -> 1 ) Change "Fizz" into "1".
 Buzz -> 1 ) Change "Buzz" into "1".
 FizzBuzz -> 1 ) Change "FizzBuzz" into "1".
 when(0)0 ) When you need to output 0, output 0.
 if(0){range(0,0)} ) If the first output is 0 (the input is 0), the range is 0 to 0.
 if(1){range(1,inf)} ) If the first output is 1 (the input is 1), the range is 1 to infinity.
 Fi1Bu1 ) Multiples of lcm(1,1) = 1, print "FizzBuzz", but it's replaced by "1".
=== Spelling Out Numbers ===
This program, covering the counter range from inclusive 1 to inclusive 10, employs various techniques to spell out the counter values:
 range(1, 10)
 when(1)one
 if(1){when(2)two}
 if(2){when(3)three
 when(4)four
 when(5)five}
 if(5){
 when(6)six
 when(7)seven
 when(8)eight}
 Fi9Bu10
 Fizz -> nine
 Buzz -> ten
==See also==
DIVSPL, a domain-specific language for solving the FizzBuzz problem
==Interpreter==
* Common Lisp implementation of the FixxBuxx programming language.
Category:Joke languages
Category:2022
Category:Implemented
Category:Languages
FizzLang

FizzLang is a esolang made by Mihai Popa. It's a DSL (Domain-Specific Language) for solving the Fizz Buzz problem. It's inspired by DIVSPL (Dustin Ingram's Very Special Programming Language)
== Syntax ==
The first line must start with this:
FIZZLANG
After that, the second line must be a line for the start and end numbers like so:
1->100
After that, you can add up to 10 lines for words like "Fizz", "Buzz", etc... Like so:
3=Fizz
5=Buzz
== Examples ==
=== Normal FizzBuzz ===
FIZZLANG
1->100
3=Fizz
5=Buzz
=== Custom FizzBuzz ===
FIZZLANG
1->50
3=Fizz
5=Buzz
7=Toad
9=Toadette
== See also ==
* DIVSPL
* FizzLang Unbounded
Category:Languages
Category:Unimplemented
Category:Output only
Category:2024
Category:Declarative paradigm
Category:Total
Category:Unusable for programming
FizzLang Unbounded

FizzLang Unbounded is a simple variant of FizzLang. the original esolang was created by User:MihaiEso and this variant is by User:Yayimhere
== the change(yea there's only one) ==
now the:
 1 -> 100
would not be there. there would just be a positive int. the program counts up from there. yea thats it
Category:Languages
Category:Unimplemented
Category:Output only
Category:2024
Category:Declarative paradigm
Category:Unusable for programming
Fizzbuzz

Fizzbuzz is a joke esolang by User:None1, it is a Nope. derivative and a no-code esolang. Every program is a FizzBuzz program, so the esolang is completely unusable for programming.
==Name==
Unlike names of other esolangs, you can write the name of esolang in any case you like and in any position of a sentence, you can even have spelling errors in the name! So
Fizzbuzz
fizzbuzz
fiZzbUzZ
FizzBuzz
FizBuz
FizzFuck
asdfghjkl
!?*#_+~&.
023838387
3.1415926
龘齉爨靐麤靈鬱亹
ƑǐǯǯƁǔǯǯ
2.7182818
6.2831853
黃河流水鳴濺濺，燕山胡騎鳴啾啾。
are all correct names for the esolang.
More formally, any name is a correct name of this esolang, even names that are already taken by other esolangs!
==Examples==
===FizzBuzz===
===Self interpreter===
===Print the name of this esolang===
===Quine===
1
2
Fizz
4
Buzz
Fizz
7
8
Fizz
Buzz
11
Fizz
13
14
FizzBuzz
16
17
Fizz
19
Buzz
Fizz
22
23
Fizz
Buzz
26
Fizz
28
29
FizzBuzz
31
32
Fizz
34
Buzz
Fizz
37
38
Fizz
Buzz
41
Fizz
43
44
FizzBuzz
46
47
Fizz
49
Buzz
Fizz
52
53
Fizz
Buzz
56
Fizz
58
59
FizzBuzz
61
62
Fizz
64
Buzz
Fizz
67
68
Fizz
Buzz
71
Fizz
73
74
FizzBuzz
76
77
Fizz
79
Buzz
Fizz
82
83
Fizz
Buzz
86
Fizz
88
89
FizzBuzz
91
92
Fizz
94
Buzz
Fizz
97
98
Fizz
Buzz
==Implementations==
A list of implementations of Fizzbuzz can be found here.
Category:Languages
Category:Joke languages
Category:Unusable for programming
Category:Implemented
Category:Output only
Category:Total
Category:Nope. derivatives
Category:2023
Category:No-code esolang
Flag

flag is an esolang created by User:None1.
The interesting thing about this esolang is that tabs are disallowed (vertical tabs are considered tabs, too).
==Syntax==
flag's syntax is:
 <flag><opcodes>
flag should be empty or contains only spaces.
==Data storage==
flag has its data stored in a bounded tape with 8 bit cells.
There is also a pointer, which points to the origin in the beginning.
All cells shound be 0 in the beginning
==Execution==
===Opcode===
Any character (except tab) is considered an opcode in flag. 
However, there are 2 types of opcode - Special opcode and Ordinary opcode.
====Special opcodes====
? Reads a character from standard input and overwrites the cell the pointer is pointing at with it. (The user should not enter tab, otherwise the program should raise an error and quit.)
! Prints the character the pointet is pointing at, if the character is a tab, raise an error and quit.
* Increment.
: Moves the pointer to the cell left of it.
; Moves the pointer to the cell right of it.
_ Makes the character after it an ordinary opcode even if it is a special opcode (tabs are still disallowed).
====Ordinary opcodes====
ordinary opcodes are legal characters that are npt.considered special opcodes, these characters are directly printed to standard output when executed.
====Tab====
Tab is considered an illegal character in flag, and flag programs which have tabs should not be allowed.
===Flag===
Flag consists of only spaces, each line of flag programs should have only one flag.
Flag controls how many times the code is executed.
N is the length of flag
N times
0 once
1 ∞ (infinity)
2 The code is executed repeatedly until the pointer points at 0. 
(just like Brainfuck's brackets)
>2 N-1 times
==Example Programs==
Hello World program:
 Hello World_!
Cat program:
 ?!
Quine:
 Quine
In fact, any program without linefeeds and tabs and special opcodes, and does not begin with a space can be a quine. That means flag has infinite number of quines.
==External Resources==
===Webpages===
The repository of flag, where the standard interpreter of flag is at.
===Interpreters===
The standard interpreter of flag written by the creator of this language (User:None1) in C++. as Windows executable. 
Category:Cell-based
Category:Languages
Category:Brainfuck derivatives
Category:2023
Category:Implemented
Flappy Bird

Flappy Bird is a concenpt esolang made by User:Yes
Commands are "pipes"
 | |
 | |
 |___|
 ___
 | |
 | |
 | |
Commands are based on height of pipes like, for example:
 | | | | | |
 |___| | | | |
 |___| |___|
 ___ ___
 | | ___ | |
 | | | | | |
 | | | | | |
Flarp

Flarp is noise putty but also an esolang.
==Commands==
 take out of cup
 squish
 trap air
 put in hair
 take out of hair
 stick to hand
 take out of hand
 stick to bed
 take off of bed
 eat
 put back in cup
 take lid off cup
 put lid back on cup
==Example program==
 take lid off cup
 take out of cup
 put in hair
 take out of hair
 eat
You will not want to do this one in real life.
Category:LanguagesCategory:Joke languagesCategory:2023Category:Unusable for programming
Flatland

The Flatland language operates on a 2D plane of instructions, but it is not grid-based (as opposed to Befunge and ><>). Rather, the execution paths are defined by geometric shapes, namely infinite lines and circles.
Inspired by ASCII-Only's chat message in PPCG.SE chat room:
: possibly lines could be execution paths, and points and circles used to indicate control structures/literals. possibly
== Synopsis ==
* A program consists of a set of points, lines and circles.
* Each point contains an instruction.
* A line represents a sequential execution path.
* A circle represents a loop.
* There is one instruction pointer (IP), moving along the specified lines and circles.
* An intersection represents a conditional; the IP transfers to another path if a certain condition is met.
== Details ==
* The language is stack-based, and the instruction set (likely) resembles one of Befunge or ><>, except the routing commands.
* Points are defined by (x,y) coords.
* Lines are defined by two points on it.
* Circles are defined by its center and radius.
* Point-on-line relationships are automatically detected with a tolerance value.
* When the program starts, IP is at the first point specified, facing positive X direction (if ambiguous, positive Y).
* The program terminates when the IP is on a line and no more points are left in the current direction.
* On an intersection, the IP turns left if the top of the stack is negative, turns right if positive, and keeps moving in its current path if zero.
* The following cases give undefined behavior (or forbidden, depending on implementation):
: - No points or no paths are specified at all.
: - The first point is not on any path.
: - Two points in a program share the same position.
: - A point in a program coincides with an intersection of two paths.
: - Three or more paths intersect at the same position.
: - Two paths are identical.
== Instructions ==
TBD.
== Syntax ==
TBD.
== Turing-completeness ==
Although it is not proven yet, it is believed to be Turing-complete by reduction from a Minsky machine given that the language has basic arithmetic (+-*/) instructions (looping and state transition are naturally represented by circles and intersections, respectively).
Category:LanguagesCategory:2018Category:Stack-basedCategory:Low-levelCategory:Two-dimensional languagesCategory:Unknown computational classCategory:Unimplemented
Flij

Flij is an esoteric programming language that takes place on an infinite tape of binary values with only one instruction of which the name of the language comes from: FLip, If was 1 Jump.
The binary values, which can be called "cells" or "bits", are referenced by integers, and each instruction is given a nonnegative integer. Negatively indexed cells are inputs in that the user can flip any of them. All cells are output bits in that they can be viewed at any time by the user. Cell 0 is randomised before every instruction, and nonzero cells start at state 0 at the beginning of the program. The first instruction is instruction 0. Programs halt when the end of it has been reached (halting also triggers if you jump past the end of the program).
Here, instructions will be notated as bit-to-flip,jump-to-this and seperated by ;, but note that the specific separators are up to the interpreter. It is also standard practice to put the instruction number as the jump number if it doesn't matter.
== Interpreters ==
Desmos, my favorite programming language
== Basic programs ==
Truth machine/cat program (assuming input is on -1 and has been done before the program began):
 -1,2;-1,3;1,3
Since output acts differently, data copying is also how a truth machine would work. Thus, the programs are the same. 
Hello world (assuming every 7 bits after bit 0 are used to create ASCII characters):
 1,0;4,1;8,2;9,3;12,4;14,5;15,6;16,7;18,8;19,9;22,10;23,11;25,12;26,13;29,14;30,15;32,16;33,17;34,18;35,19;37,20;43,21;44,22;45,23;47,24;48,25;49,26;50,27;51,28;53,29;54,30;55,31;56,32;57,33;58,34;59,35;62,36;64,37;65,38;67,39;68,40;71,41;72,42;75,43;79,44;84,45
Logic gates AND on inputs on -1 & -2 to 1:
 1,0;-1,2;-2,3;-1,7;-2,7;-1,5;-1,8;1,7
Category:Languages Category:Cell-based Category:OISC Category:Implemented
Flip

Flip is a two-dimensional esoteric programming language designed by Rune Zedeler and Erik Søe Sørensen. Computation is performed by balls carrying values colliding with playfield elements; it has been described as "a little like a game of billiards, if you play Programmers' Billiards." The only other data storage mechanism is the possibility to self-modifyingly flip diagonal walls (called "flippers") - similarily to how the much newer BackFlip operates. Combined with elements which split and combine balls this requires rather than allows for multithreaded programming.
As of Flip 2.0 the board consists of infinitely many identical layers. There have been added instructions to move balls up and down between the layers.
Because the ball values are limited to 32 bit we are quite certain the Flip 1.0 was not Turing complete - even though we have not made a formal proof for this. Flip 2.0 is clearly Turing complete because the layers can be used to implement a stack by saving one ball (stack element) on each layer.
Flip was inspired by Wierd, but has more in common with multi-threaded Bloated SNUSP.
Though, notice that Flip is two years older than SNUSP.
==External resources==
* Flip Home Page, which contains a Java interpreter and sample programs.
* Flip interpreter on github, which contains another Java interpreter and IDE and source code.
Category:Languages
Category:Two-dimensional languages
Category:Concurrent programming
Category:Turing complete
Category:Implemented
Category:2001
FlipFlop

FlipFlop is a AI-Generated esolang (generated with esobot (kinda) from the esolangs server) which is basically 10-bit binary creator. Created by User:Ractangle
==Instructions==
Command	It's action
F 	Flips the value of the cell that the pointer is currently on
P 	Prints the value of the current cell
L 	Moves the pointer left
R 	Moves the pointer right
E 	End the program
==Examples?==
 FFRFPE
Ignores the first cell by flipping it's bit two times, then flip the second cell and print it
Minified:
 RFPE
=== 0 Interpreter ===
 PE
==== Another One ====
 THIS PROGRAM IS AN INTERPRETER FOR THE JOKE ESOTERIC PROGRAMMING LANGUAGE 0
==Implementation==
cell=[0];i=input("FF:")
p,cp=0,0
while True:
 if i[p]=="F":cell[cp]=int(not cell[cp])
 elif i[p]=="R":
 if cp>len(cell)-1:cell.append(0)
 cp+=1
 elif i[p]=="L":
 if cp<len(cell):cp=0
 cp-=1
 elif i[p]=="P":print(cell[cp])
 elif i[p]=="E":break
 if len(i)
Category:LanguagesCategory:2024Category:Generated by AICategory:Unusable for programmingCategory:Implemented
Flipfractal

Flipfractal is an experimental variant of Memfractal, which was created by User:Zzo38. It takes ideas from BackFlip and the Memfractal specifications by User:Camto.
==Specification==
The program has an unlimited space and does not have to be bordered, but it has to have all of:
 ^ V < >
each occurring exactly once in the program, they are the entry points and exit points.
'#' (without quotes) is a reflector which reflects the IP back.
+ is the same as Memfractal, the program enters itself recursively with a separate copy.
/ and \ are the same as in BackFlip, they are flipping mirrors.
Programs can either be surrounded by '#'s, or, if the IP goes out of bounds, it will loop back around to the other side. Aka, the program takes place on a torus.
==Examples==
Truth-machine:
 #V##
 #/+<
 >X #
 #^##
if 1, X = / otherwise 0, X = \, come in from left
Alternative Truth Machine Design:
 1
 #V##
 0>\+<1
 #^##
 0
Entry of program from 0 locations instantly halts. Entry of program from 1 locations loops forever.
Program showcasing tree stack memory and highly complex behavior:
 #V###
 #+++#
 >/\\<
 #^###
Extended Machine & Extended Machine Alternative?
 #V##...### #V####...####
 #+++...++# and variant: #?????...???#
 >???...??< #+++++...+++#
 #^##...### >?????...???<
 #^####...####
where ? is either / or \ (or even include ' 's as well, if needed for NOPs (?))
The right-most machine variant appears to be the same machine, and the top part does not appear to effect it in any way.
(make it it's own language ?)
==Multi-threaded Variant==
Additional Commands | and -:
 >|
and
 V
 -
splits IP into 2 IPs, and
Multiple entrances/exits are allowed:
 VVVV
 > <
 ^##^
However, there must be a minimum of one on each side, otherwise what will occur is undefined.
Halt/End Thread Instruction
 V 
 B-<
B, the black hole, stops an IP and ends it. (The Black Hole is not necessary but does make certain programs easier to write. However, if someone wishes to exclude it from the specification because it makes things too unrestricted, that still counts, hence it is an optional instruction.)
==Computational class==
Unsure, based on my test programs it is (i think) at least as powerful as a Tree Stack Automaton, which is more powerful than a Push Down Automaton. I believe that it actually is a Tree Stack Automaton, in some sense, but I can't prove this just yet. There are two variants of Tree Stack Automata, restricted and unrestricted. Since the language here allows infinite nesting, it would count as unrestricted, therefore making it Turing Complete, however, this language still needs proof of being equivalent to a Tree Stack Automaton, and proof that the unrestricted part is usable.
Category:Unknown computational class Category:Two-dimensional languages Category:Self-modifying Category:Languages
Flippant

Flippant is a language based on inserting substrings and printing characters. 
==Syntax==
Flippant is based on a string and a list of steps. The steps are implicit.
==Commands==
Command	Purpose
p 	Print the string and go to the next step.
d(x,y) 	Delete all characters starting from the xth character and ending at the yth character(inclusive) and go to the next step. If there are no characters left, it halts via a syntax error.
f(x,y) 	Insert the string beginning at the xth character to the yth character to the beginning of the string and go to the next step.
a(x) 	Set position x of the string as the ASCII value of that position and go to the next step.
s(x) 	Go to step x.
h 	Halt
Category:Languages
Category:2019
Category:Unimplemented
Flippers

ok, so this uses marbles
== Commands ==
 #, wall for thing that defines marble direction
 \*, marble that goes right if #O, else if O#, left, right by default,
 marbles go down, only, when they don't have a symbol below them,
 when they go down, the direction that they start in doesn't work
 _, normal floor
 \, marbles fall into this then they go right
 /, marbles fall into this then they go left
 [, like the \, but when it gets touched, it turns into ]
 ], like the /, but when it gets touched, it turns into [
 A-Z, outputs
== Program ==
 #********* #
 #_________ ##
 # [ #
 ######## ##
 # / \ #
 A B
Flkl

== Flkl programming language ==
Flkl is a language made by Salmmanfred in about 3 hours 
=== The spec ===
|a = nothing
f = load a string/int into the data
p = print the data in the data
q = quit
m = minus (m10a)
e = if the data is equall to 1 it moves to a new row (e1a)
l = move to line 
n = new line
=== Example code ===
this counts down from 100 to 1 and says bruh at 90:
 f100|al1a
 npm1ae0|2ae90|3al1a
 nq
 nfbruh|apf89|al1a
hello world:
 fhello world|ap
 
=== Interpreter ===
Official interpreter 
Category:Implemented
Category:Languages
Category:2021
Flobnar

Flobnar is a two-dimensional functional language, designed by Chris Pressey in 2011
as a sort of functional-programming counterpart to Befunge, on the occasion of its 18th birthday.
==External resources==
* 
Category:Languages
Category:Implemented
Category:Self-modifying
Category:Functional paradigm
Category:Turing complete
Category:Two-dimensional languages 
Category:2011