nyuuzyou/wikis huggingface dataset:
Flop

== Programs ==
=== Simple binary 3 bit counter ===
 add a
 add b
 add c
 clock c
 to c b
 to b a
 when c 0
 when b 0
=== Locked values ===
==== to 0 ====
 add a
 clock a
 to a a
 when a 1
==== to 1 ====
 add a
 clock a
 to a a
 when a 0
== Interpreter ==
 pflops = {}
 flops = {}
 transitions = {}
 whens = {}
 clocks = []
 program = """
 add a
 add b
 add c
 add d
 clock d
 to d c
 to c b
 to b a
 when d 0
 when c 0
 when b 0
 when a 0
 """.split("\n")
 def floop(flopper):
 flops[flopper] = 1-flops[flopper]
 if flops[flopper] == whens[flopper] and flops[flopper] != pflops[flopper]:
 try:
 floop(transitions[flopper])
 except KeyError:
 pass
 for commands in program:
 parts = commands.split(" ")
 if parts[0] == "add":
 flops[parts[1]] = 0
 pflops[parts[1]] = 0
 elif parts[0] == "to":
 transitions[parts[1]] = parts[2]
 elif parts[0] == "when":
 whens[parts[1]] = int(parts[2])
 elif parts[0] == "clock":
 clocks.append(parts[1])
 i = 0
 while i < 16: #dependent on program length
 for flop in flops:
 print(flop+": "+str(flops[flop]))
 print("")
 for flop in flops:
 if flop in clocks:
 flops[flop] = 1-flops[flop]
 if flops[flop] == whens[flop] and flops[flop] != pflops[flop]:
 try:
 floop(transitions[flop])
 except KeyError:
 pass
 pflops = flops.copy()
 i += 1
Flow Uncontrolled

Flow Uncontrolled is a language that requires self modification to do pretty much anything.
==Arguments==
The language has three instructions, written like Python function calls. The instructions all have at least 1 argument.
Arguments can be strings, numbers, nil, read(x), cln(), or rand().
strings can have escaped quotation marks (\"), and now we need an escaped backslash (\\).
read(x) returns the contents of line x.
cln() returns the line # currently being run.
rand(x, y) returns a random number between x and y.
===Operations===
The operations in the language include + and -, which only works if both sides are numbers; and concatenation(&), which works on any data type.
Boolean operations include =, >, <, and !=(not equal)
==Instructions==
The two instructions that write lines both overwrite the lines.
Instruction 	Action
out(x, y) 	Output the contents of line number x. If y is "Y" (without quotations), print with a newline.
input(x) 	Take a line of input and write it to line x
write(x, y, z,)	Write y to line x if z evaluates to true. (z is optional, if it is not there the write will be unconditional)
| 	begin one-line comment
If you need multiple commands on one line, separate them with a colon.
==Examples==
===Quine===
out(1)
===Hello World===
write(1, "Hello, World!")
out(1, N)
===Truth-machine===
input(1) | overwrites itself with the input
write(cln() + 1, read(cln()), read(1) = 1) : out(1)
out(0, N)
===Cat program===
| input here
input(1) : write(cln() + 1, read(2), read(1) != "") : out(1)
===A+B problem===
The two values must be placed on separate lines in STDIN due to how input() works
| A gets placed here
input(1) : input(2) | B overwrites this line
write(3, read(1) + read(2)) | result overwrites this line
out(3, Y)
===99 bottles of beer===
write(1, 99) | place the amount of bottles
write(2, " bottles of beer on the wall,") | place all of the lyrics
write(3, " bottles of beer.")
write(4, "Take one down, pass it around,")
write(5, " bottles of beer on the wall.")
write(6, "1 bottle of beer on the wall,")
write(7, "1 bottle of beer.")
write(8, "No more bottles of beer on the wall.") 
| begin the printening
write(cln() + 1, "out(1, N) : out(2, Y) : out(1, N) : out(3, Y) : out(4, Y) : out(1, N) : write(1, read(1) - 1) : out(5, Y) : out(9, Y)", read(1) > 1) : write(cln() + 1, "out(6, Y) : out(7, Y) : out(4, Y) : out(8, Y)", read(1) = 1) : write(cln() + 2, read(cln()), read(1) > 0)
Category:LanguagesCategory:Turing completeCategory:Self-modifyingCategory:Unimplemented
Flow chart

flow_chart is an interpreted language that takes raster images of flow charts as its input. It is currently a work in progress.
The language is designed so that only black and non-black pixels are distinguished by the interpreter so that any program can be drawn as a
black-and-white image in order to be easily printable. This also allows the programmer to add comments by simply drawing them in other
color than black. There are several types of blocks to contain commands, declarations, conditions, directives etc. which must be written
using flow_chart bitmap font. The language supports some advanced features such as modules, namespaces, working with files, strings,
lists etc.
== Examples ==
===More sophisticated hello world===
===Simple math library defining factorial function and a global constant===
==External resources==
* flow_chart on GitHub
Category:Languages
Category:Turing complete
Category:Unimplemented
Category:Non-textual
Category:High-level
Flower (Archived)

Flower is a programming language. Programs simply consist of a seed for a random number generator.
== Structure ==
A Flower program consists of a seed for a random number generator. The seed is used to generate an array of integers, which is then treated like an infinite polynomial. For example, if you end up with [3, 2, 4, 1, ...], you get the mathematical function 3 + 2x + 4x^2 + x^3...
== Computational class ==
No random number generator can ever possibly generate all infinite sequences, as there are as many infinite sequences as there are real numbers, while seeds must be finite and thus correspond to integers.
Category:Languages Category:Unimplemented Category:2015
Fluffle Puff

Fluffle Puff (also known as BrainPuff or FluffleFuck) is an esoteric programming language created by juju2143 in January 2014. It is a simple Brainfuck variant designed to be similar to the speech of My Little Pony: Friendship is Magic fan character Fluffle Puff.
== Language overview ==
Fluffle Puff is mostly identical to Brainfuck, except the symbols are substituted:
Brainfuck	Fluffle Puff 	Description
> 	b 	Move the pointer to the right
< 	t 	Move the pointer to the left
pf 	Increment the memory cell under the pointer	
bl 	Decrement the memory cell under the pointer	
. 	! 	Output the character signified by the cell at the pointer
, 	? 	Input a character and store it in the cell at the pointer
[ 	*gasp* 	Jump past the matching *pomf* if the cell under the pointer is 0
] 	*pomf* 	Jump back to the matching *gasp* if the cell under the pointer is nonzero
Due to the simple substitution, Fluffle Puff can be considered equivalent to TrivialBrainfuckSubstitution("b","t","bf","pl","!","?","*gasp*","*pomf*") and as such is Turing-complete.
== Examples ==
This is a simple Hello, world! program:
 pfpfpfpfpfpfpfpfpfpf*gasp*bpfpfpfpfpfpfpfbpfpfpfpfpfpfpfpfpfpfbpfpfpfbpfttttbl*pomf*bpfpf!bpf!pfpfpfpfpfpfpf!!pfpfpf!bpfpf!ttpfpfpfpfpfpfpfpfpfpfpfpfpfpfpf!b!pfpfpf!blblblblblbl!blblblblblblblbl!bpf!b!
== Implementations ==
* Reference implementation
* Brainfuck to Fluffle Puff converter
Category:LanguagesCategory:Turing completeCategory:Turing tarpitsCategory:Cell-basedCategory:Brainfuck equivalentsCategory:ThematicCategory:ImplementedCategory:2014
Flurry

Flurry is a strictly evaluated functional programming language created by User:Challenger5 and inspired by Brain-Flak.
== Definition ==
The main difference from Brain-Flak is that there is only one stack, which contains only functions. Functions are allowed to modify the stack, but are otherwise pure.
All nilads and monads return functions. Rather than denoting integer addition, juxtaposition denotes function application.
Nilads take no arguments and return a function. There are four of them:
* [] evaluates to the height of the stack as a Church numeral.
* () evaluates to the K combinator.
* <> evaluates to the S combinator.
* {} evaluates to a value popped off the stack or to the I combinator if the stack is empty.
Monads enclose one or more operations (nilads or monads) and return a function. There are four of them:
* [abc] reduces abc by function application and then returns the result. It essentially serves as a grouping operator like parentheses.
* (abc) reduces abc by function application, and then pushes the result to the stack, returning it.
* <abc> reduces abc by function composition and then returns the result.
* {abc} returns a function that:
** Takes a single argument and pushes that argument to the stack.
** Reduces abc by function application.
** Returns the result.
The program is a list of zero or more nilads and monads. The initial stack content is the Church-encoded representation of the input.
== Snippets ==
=== Numbers ===
Literal 0:
[<>()]
Literal 1 (also the I combinator):
{{}}
Literal 2 and higher:
2 : {<({}){}>}
3 : {<({})({}){}>}
any n : {< `n-1 copies of ({})` {}>}
=== Arithmetic ===
Return the successor function for Church numerals (\a b c. b (a b c)):
<><<>()>
Pop two Church numerals and return their sum (or use {<><<>(){}>} for a function of two arguments):
<><<>(){}>{}
Pop two Church numerals and return their product (or use <<>()> for a function of two arguments):
<{}{}>
Pop two Church numerals n m and return m**n:
{}{}
=== Miscellaneous ===
Duplicate the top value on the stack and return it:
(({}))
Return the iota combinator (\x. x S K):
{{}<>()}
Swap the top two stack elements:
<[<><<>()[<>{{}}]()>]()[<>{{}}]()>{}{}{{<>()}}
<><<>()<>[<>{{}}]()>[()()]{}{}{{<>()}} -- by Bubbler
== Computational Class ==
Flurry is Turing-complete (even without the stack) since one can directly convert an SK combinator calculus term into Flurry code using only <> (for S), () (for K), and [...] (for function application).
== External Links ==
* Reference implementation in Haskell
* Implementation in Standard ML
* Implementation in OCaml
* Implementation in Typescript (Online interpreter)
Category:Languages Category:Functional_paradigm Category:Stack-based Category:Implemented Category:Turing_complete Category:2019
Flux

Flux has more features then its lesser twin (Indifferent) and the idea of Flux came first (then Indifferent got implemented first because its the same language as Flux with less features)....
(still in development by Scudmaster11)... 
History
its syntax has changed ALOT... its history started out as a implementation of FALSE with stack rotation and would of call it (FALSELY) and then didn't know how to do that (didn't know how to make that interpreter).... so the syntax changed alittle bit...kept the same amount of variables and the stack now replaced with an array... (update 2 on syntax)... (update 3 on syntax) removal of variables and now everything resides within addresses... (update 4 on syntax)... (update 5 on syntax)... (update 6 on syntax "same as Indifferent and the one of today for Flux")... when i started updating the syntax alot to try and get it to work {untill the final one}... the project became a run away experiment rather then a (lets make a custom esolang)
... settled on the extractor method (alter the main code abit for the interpreter to be really simple and not overly complicated)... both Indifferent and Flux have 0 built in callback stacks in the background (so when a goto is called... it cant go back... there is also 0 built in loops so manual loops have to be made) {{both Indifferent and Flux will be made in Penguin Mod [a mod of scratch "please be kind about me being a scratcher"]}} (Flux is basically ALOT more flexible then Indifferent... they are twins)
this page is to only list how the features it has that Indifferent doesn't (so to get a foundation... please goto the Indifferent page for the understanding)
Flux with its ! actions.. it has - + along with * and / (add, subtract, multiply, and divide)
in if statements (?) it has > = and ! (! is also known as =!)
along with pulling up goto locations (#) by using the number inside a address
delete all of output through code and some more
(Indifferent code can run on Flux interpreter but not vise versa)
as always... here if the fib sequence (its the same as Indifferent as they are twins after all)
!1?1!1 "0"end" " "end" !1?1!2 !1?0!3 #1 ??5!3>{1 $1 " "end" !2!1!2+!2 $2 " "end" !2!1!2+!1 !2?1!3+!3 ]1 [1
(update later perhaps) (time of writing April 20th, 2024)
Category:Languages
Category:Joke languages
Fm

For each m >= 2, Fm is a computational model based on editing a finite 
unbounded string on an alphabet of m letters. It is derived from Brainfuck 
in the spirit of the Wang program formulation of Turing machines, by using 
only the five instructions '+' '<' '>' '[' ']' and by applying a cyclic 
ordering to the alphabet, with '+' changing a letter to the next letter 
in cyclic order.
==Computational class==
F2 has been proved Turing-complete without reference to the Turing completeness of other Brainfuck languages, by directly simulating a universal tag system in F2. All Fm languages are therefore Turing-complete, because they can easily simulate F2.
==External resources==
* that is archived. The more frequently referenced Geocities page of r_e_s_01 appears lost.
* , with code and examples, including:
** 
** 
==See also==
* Smallfuck
* Wang program
Category:Computational models
Category:Brainfuck derivatives
Category:Turing complete
Fnaf sort

Fnaf sort is an esoteric sorting algorithm that kills the data with the scooper until it's sorted properly.
== Example ==
First let's say we have this dataset.
 1
 45
 3
 3008
We use the scooper on them.
 1435
 003
 8
And we repeat until this iteration:
 4
 15
 38003
Or any other one that is proper.
Category:Concepts
Focal-2D

Focal-2D programming language.
This language is based on the previously created "sim41 emulator".
The emulator is an implementation of the Hewlett Packard HP41 calculator. The original language of the HP41
was known as "The forty one calculator language -Focal-"
Focal-2D programs could be written on a two dimensional grid. The original language for the HP41 was "one dimensional"
That language could be written using a single column of steps only. Each row contained a single programming step.
The novelty of Focal-2D is related to each step is contained in a cell. That cell is part of a 2D grid.
On the original HP41 programming language, the programs were read from top to bottom , step by step.
On Focal-2D exist the concept of direction of evaluation. This direction could be "up", "down", "left" or "right".
Depending of the current direction of evaluation, the following step is read from an adjacent cell according to the
present direction.
There are programming commands (exclusive of Focal-2D) used to change the direction of evaluation.
If the present direction of evaluation in a program is from left to right, then:
 \\ changes it to from top to down.
 // changes it to from down to top.
Example:
( Set the initial direction of evaluation to left-right )
(Assume each programming command saved on a cell. Here I will use spaces instead of cell separators )
 + 2 \\
 *
executes the instructions:
1.) + (sum the first two values of the stack and place the result on the first stack level) 
2.) 2 ( enter the number two to the stack )
3.) * (Multiply the first two values of the stack and put the result on the first stack level)
A similar program using // is:
 *
 + 2 //
In this case // changed the direction to "down to top" and later the "*" command was evaluated.
In general:
If present direction is "top-down" // changes it to "right-left"
If present direction is "top-down" \\ changes it to "left-right"
If present direction is "down-top" // changes it to "left-right"
If present direction is "down-top" \\ changes it to "right-left"
If present direction is "left-right" // changes it to "down-top"
If present direction is "left-right" \\ changes it to "top-down"
If present direction is "right-left" // changes it to "top-down"
If present direction is "right-left" \\ changes it to "down-top"
Details of the implementation could be found searching internet for the "HP41 Emulator Page and MyRPL calculators". Or go to https://sim41.webcindario.com/.
Category:Languages Category:Two-dimensional languages
Fold

Fold is a unimplemented language devised by user:moon.
 
== Instruction set ==
# >: Move the memory pointer to the left
# <: Move the memory pointer to the right
# &: Start a fold in the direction of the instruction pointer, will end at contacting a seam, anything under the fold is incremented, a fold moves along at one cell per tick
# *: Creates a seam at the location of the memory pointer
# $: Creates a loop in the program tape, ends at @, the loop goes in the direction that the program pointer is moving in
# !: Flips the direction of the memory pointer
# ?: Skips the next instruction if the value under the memory pointer is not 0
# ^: Cuts a loop, allowing the execution of the program to continue normally
# @: Marker for $, doesnt do anything unless linked to a loop, in which it moves the program pointer back to the loop it is linked to
# .: Patches a seam, if existent, at the location of the memory pointer;
# :: print the value under the memory pointer
# (: undoes a fold if the memory pointer is on the start point of a fold
# ;: Get input and put it under the memory pointer
# #: Branches the code and the child skips the next instruction
# ~: Ends execution
== Minimal Examples ==
 $>#&@ this is a infinite incrementer, acting like [0,1..] the Haskell equivalent to it
More info later
Category:Languages Category:Unimplemented Category:2016 Category:Cell-based
Folder

The Folder programming language is an esoteric programming language by User:Rdococ with a variety of interpreters, compilers and intermediary formats.
== Semantics ==
A Folder contains various files and other folders. The user can send input to the program by navigating to other folders and opening files to alter the state of the currently running program.
Folders can contain images, videos and documents for output. Extensions to Folder support embedding programs written in other, potentially Turing complete programming languages.
== Usage ==
Folder is an interpreted programming language. Almost every operating system comes with a Folder interpreter pre-installed, and one of the simplest is the cd command. Microsoft Windows offers the commonly used interpreter Explorer, and a wide variety of open-source interpreters are available for Linux.
Folder programs can be compiled into a set of intermediary bytecode formats, the most common of which is .zip.
== Examples ==
This Folder represents a turnstile. Beginning in the 'closed' state, you can open 'unlock' to open the turnstile, and 'lock' to close it again.
* lock
:* closed (hidden)
::* unlock => opened
:* opened (hidden)
::* lock => closed
:* start => closed
A Folder for adding 2 binary numbers of arbitrary sizes. Input should alternate between the two numbers starting from the LSB e.g. to calculate 1010 + 0011, follow the links 01110010 while memorizing the sequence of images.
*adder
:*A=0
::*B=0 (=> "out_0")
::*B=1 (=> "out_1")
:*A=1
::*B=0 (=> "out_1")
::*B=1 (=> "out_0_carry")
:*out_0 (hidden)
::*0.png
::*next (=> "adder")
:*out_1 (hidden)
::*1.png
::*next (=> "adder")
:*out_0_carry (hidden)
::*0.png
::*next (=> "adder_carry")
:*out_1_carry (hidden)
::*1.png
::*next (=> "adder_carry")
:*adder_carry (hidden)
::*A=0
:::*B=0 (=> "out_1")
:::*B=1 (=> "out_0_carry")
::*A=1
:::*B=0 (=> "out_0_carry")
:::*B=1 (=> "out_1_carry")
Category:Languages
Category:Finite state automata
Category:Implemented
Foldy

Foldy is an esolang created by squareroot12621. It's a 2D esolang, like some others, but it starts out as 1D.
== Documentation ==
In Foldy, the code starts out as 1D. You can fold it into 2D with the { and } commands.
...That's basically the main part of Foldy. The rest of the commands are in this table:
Instruction	Action
␣ 	No-op
0 to 9 	Push 0 to 9 to the stack
+ 	Add the top two values on the stack
- 	Subtract the top two values on the stack
* 	Multiply the top two values on the stack
: 	Integer-divide the top two values on the stack. Blows up if dividing by 0
< > ^ v 	Force the IP to go in a certain direction
_ 	Bounce the IP
$ 	If the top item on the stack is greater than 0, skip the next instruction
? 	Replace the top of the stack with a random number in [0,\,\text{top of stack})
{ 	If fold mode is on: Fold the rest of the code counterclockwise
{ 	If fold mode is off: Turn counterclockwise
} 	If fold mode is on: Fold the rest of the code clockwise
} 	If fold mode is off: Turn clockwise
! 	Print the top of the stack as a character
. 	Print the top of the stack as a number
; 	Get a character from input
, 	Get a number from input
@ 	Terminate the code
& 	Duplicate the top of the stack
~ 	Pop the top of the stack
[ 	Move the top of the stack to the bottom
] 	Move the nth item on the stack to the top
# 	Toggle fold mode. By default, this is on
== Interpreters ==
* Python interpreter (GitHub)
Category:Languages Category:Two-dimensional languages Category:2025 Category:Cell-based Category:Implemented
Font

The esoteric languages community has created several programming fonts. As the list is getting too long for a wisdom entry, I will list them here.
* http://www.orenwatson.be/fontdemo.htm ​\oren\'s 8×16 bitmap font Neoletters. fixed grid of 8×16 pixels for single-width characters and 16×16 pixels for double-wdith characters. covers a very large set of characters, including hangul and a large selection of kanji. different characters try to be visually distinguishable to help in programming.
* https://github.com/lifthrasiir/unison/ lifthrasiir's 8×16 hybrid bitmap font Unison. works as a bitmap point with fixed 8×16 pixel grid for single-width characters and 16×16 pixels for double-wdith characters with a few characters even wider up to six cells width. can also be used as a vector font scalable to larger sizes, where pieces of the glyph shapes are still aligned to the same grid but need not occupy full pixels, and this is compiled from the same source as the bitmap version. has the second largest coverage of characters among these fonts. different characters try to be visually distinguishable to help in programming.
* http://www.math.bme.hu/~ambrus/pu/fecupboard20-c.pcf.gz b_jonas's 10×20 bitmap font FeCupboard20. small coverage. different characters try to be visually distinguishable to help in programming.
* https://github.com/fis/rfk86/tree/master/web/font fizzie's 4×6 bitmap font.
* https://firefly.nu/up/fonts/ FireFly's bitmap fonts in multiple small sizes. 
* http://tom7.org/fixedersys/ Tom7's bitmap fonts FixederSys, in two sizes.
* https://github.com/zzo38/scorpion/tree/trunk/gui/font Bitmap fonts created by zzo38, mainly from combinations of other fonts, but some characters are custom design. Supports TRON character code.