nyuuzyou/wikis huggingface dataset:
Finite-state mach... wait, WHAT!?

Finite-state mach... wait, WHAT!? (or simply FSMWW) is a programming language that looks like an FSM, but it can construct and execute another program, which can use more memory.
== Memory ==
Same memory model as in brainfuck (8-bit cells), but the tape is limited (has finite number of memory cells).
== Source code ==
The first character of the source code must be either : or ;.
Then a decimal number follows (sequence of decimal digits). That number (we call it N) represents the memory size (number of memory cells). Data pointer is at the cell with index 0 and the last accessible cell has index N-1. If the memory pointer goes outside the memory (becomes -1 or N), then throw an error.
The rest of the source code (after the number) is a brainfuck program. Execute it as a regular brainfuck code (but with limited memory). When (if) the brainfuck program halts, do the following:
* If the first character of the source code is ;, then print the brainfuck output and terminate the whole FSMWW program
* If the first character of the source code is :, then interpret the brainfuck output as a FSMWW program
Note: in case of :, the input is not reset (what has already been read remains read). Reading after the last input character gives 0.
== Examples ==
=== Cat program ===
 ;1,[.,]
Try it online
Another one:
 :1+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.----------.-----.+++++++++++++++++++++
 ++++++++++++++++++++++++++.---------------------------------------------.--.++++++++++++++++++++++++
 +++++++++++++++++++++++++.
Try it online
The second example generates the first example and then executes it.
=== Hello, World! ===
 ;1++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++
 ++++.+++++++..+++.-------------------------------------------------------------------.------------.+
 ++++++++++++++++++++++++++++++++++++++++++++++++++++++.++++++++++++++++++++++++.+++.------.--------.
 -------------------------------------------------------------------.
Try it online
== Computational class ==
Unknown.
== Interpreters ==
* Interpreter
Category:Languages
Category:Unknown_computational_class
Category:Brainfuck_derivatives
Category:Implemented
Category:2020
Finite Groups

Finite Groups is language with a mathematical-looking syntax. Its data types are lists of elements of finite groups. The supported groups are cyclic groups, dihedral groups, symmetric groups, alternating groups, dicyclic groups, and cartesian products of groups. As permutations can be applied, it's also a functional language.
==Computational class==
Finite Groups programs always halt.
==Examples==
Hello world
 "Hello world!\n"
rot13
 let a = "abcdefghijklmABCDEFGHIJKLMnopqrstuvwxyzNOPQRSTUVWXYZ"
 r : Ca = "n"
 i : Ca,i = i
 in Sa→rai
touppercase
 let t = !"01"
 f = tt
 a = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
 u : C[a] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 l : C[a] = "abcdefghijklmnopqrstuvwxyz"
 m = S["01"*a->C[f*u,t*u,f*l,t*l]]
 i : C[a,i] = i
 in (m(f*i))P
quaternions
 let q = Dic["1-"]
 c : C[q] = "-"
 i : Dic["1-"] = cc
 j : Dic["1-"] = cccc
 k = ij
 in k
==External resources==
* Description and interpreter
* http://en.wikipedia.org/wiki/Finite_group
Category:Languages
Category:Implemented
Category:2010
Category:Functional paradigm
Finite State Brainfuck

Finite State Brainfuck is a brainfuck variant that is equivalent to a finite state machine, due to being a read only Turing Machine.
==Instructions==
Brainfuck without + and - instructions, however the tape should have the values inputted initially:
==Program example==
 0 5 1 8 234 13 9 7 7 2 <-- (== TAPE, but rest is filled w/ 0s after this initial input)
 >[.>] <-- (Program)
==Instructions list and ,==
Instructions are
 > < [ ] .
Allowing use of the input instruction:
 ,
Will make it more powerful (in some sense), but still in the same class as a FSM.
Perhaps this idea could be extended in some ways while keeping the FSM status of the language, like say
 { ... } <--- Unconditional Infinite Loop for ... (or even zeno infinite loop?)
and if that changes the language's class.
Category:Languages Category:2020 Category:Finite state automata Category:Brainfuck derivatives
Finite looping automaton

Finite looping automaton is a misleading, or outright incorrectly named esoteric programming language attempt invented by User:A where some programs, demonstrated by the examples below, can loop infinitely. It could theoretically simulate only loops with predicted numbers of iterations (e.g., for loops), but using self-modification, it can simulate infinite loops.
==Syntax==
* n ... ]: loop ... n times, with n decremented after each looping process. Executing 0 times is a comment.
* >: Move the program pointer (not the program counter, its motion depends on the program) right.
* <: Move the program pointer left.
* +: Increment the instruction's ASCII code pointed by the program pointer.
* -: Decrement the instruction's ASCII code pointed by the program counter.
* *: Halts the program.
* Any other command puts that ASCII code into the program.
The whole program gets outputted on the end of the execution.
==Example programs==
===Infinite loop===
 9+]
 
 -
===Looping counter===
This evaluates only 1 iteration. The user should execute the outputted program repeatedly.
 0+
This loops forever:
 90+>+<]
===Downward counter from 9 to 0===
This is used as a counter-argument. It is usable for computation...
 9-]
Category:Languages
Category:2019
Category:Unimplemented
Category:Self-modifying
Category:Output only
Category:Unknown computational class
FireStarter

FireStarter is a language idea created by User:DoggyDogWhirl.
==The idea==
The idea is to create a programming language whose syntax requires syllables to be in a rhythm similar to Billy Joel's "We Didn't Start the Fire". After a certain amount of lines, a copy of the main verse would be required. Thus, the code could be sung to the tune of the song. (rhyming not required, but encouraged)
The language itself could manage variables, stacks, a tape, anything. The main idea is the syllable structure.
The main problem is that the syllable structure in the song itself is not as consistent as expected (for copyright reasons, only the structure itself is shown here, not the song's actual lyrics):
 OOOO-OOO
 O OO-OOO
 OOOO-OOOO
 OOOO-O
 OOOO-OOOO
 OOOO-OOOO
 OOOO-OOOO
 OOOO- O
 OOO -O O
 OOO -OOO
 O O -OOOO
 OOOO-OOO
 OOOO-O O
 OOOO-O O
 OOOO-OOOO
 OOOO-O O
 
 OOOO-OOO
 OOOO-OOO
 OOOO-OOOO
 OOO -O
 O O -OOO
 OOOO-O O
 O O -O O
 OOOO-O
 O O -O O
 OOOO-OOO
 OOOO-OOO
 OOOO-OOO
 O O -OOO
 OOOO-O O
 OOO -OOO
 OOOO-O O
 
 OOO -OOO
 OOOO-OOO
 O O -OOO
 O OO-OOO
 OOO -OOO
 OOOO-O O
 O OO-OOO
 OOOO-OOO
 OOOO-O O
 O OO-OOO
 OOO -O O
 OOOO-O O
 O O -OOO
 OOOO-OOO
 OOOO-O O
 OOOO-O O
 
 OOO -O O
 OOOO-O O
 O O -O O
 OOOO-O O
 OOOO-OOO
 OOOO-OOO
 O O -O O
 OOO -OOO
 O O -OOO
 OOOO-OOO
 OOO -OOO
 OOOO-OOO
 
 OOO -OOO
 OOOO-OOO
 O O -O O
 OOO -O O
 OOOO-OOO
 OOOO-O O
 OOOO-OOO
 OOOO-OOO
 OOOO-OOO
 OOOO-OOO
 OOO -OOO
 O O -OOO
 OOOO-OOO
 OOOO-OOO
 OOOO-OOO
 OOOO-OOO
 --------
 -------- Syllable structures and occurrences: 
 O O -O O 5
 O O -OOO 6
 O O -OOOO 1
 OOO -O 1
 OOO -O O 4
 OOO -OOO 8
 O OO-OOO 4
 OOOO-O 2
 OOOO- O 1
 OOOO-O O 14
 OOOO-OOO 24
 OOOO-OOOO 6
 
 O O 12
 OOO 13
 O OO 4
 OOOO 47
 
 O 3
 O 1
 O O 23
 OOO 42
 OOOO 7
Category:Languages Category:Concepts
Firefly

Firefly is an esoteric programming language for the BBC micro:bit.
== Rationale ==
The micro:bit is a tiny single-board computer that runs Python. It supports several input and output devices, including
a speaker (version 2) and a 5x5 array of LEDs, each of which supports ten brightness levels. Firefly is a tiny esolang
meant to run on the micro:bit (or the console for program development).
The language follows a "Firefly" as it flies over the 5x5 grid of LEDs. As it flies, it leaves behind it a trail
of light. In this way, the Firefly can draw pictures on the 5x5 grid. The language supports music and animation via double buffering.
Firefly is featured in Chapters 14 and 15, and the appendix, of the book Strange Code: Esoteric Languages That Make Programming Fun Again (No Starch Press, 2022).
== Language Description ==
Firefly programs are strings of single-character commands. Some affect the Firefly's movement, others music output, and others
which of the two display buffers is shown and drawn to. Any string of valid command characters is a valid Firefly program, which
makes the language useful for genetic programming experiments.
== Commands ==
 
Instruction	Effect
N 	Move north
S 	Move south
E 	Move east
W 	Move west
T 	Stay put (tick of the clock)
0-9 	Constant intensity value
I 	Increment the current value
D 	Decrement the current value
M 	Move only, no change in value
R 	Random value 1 through 9
X 	Show grid A
Y 	Show grid B
A 	Draw on grid A
B 	Draw on grid B
C 	Clear active grid
V 	Clear grid A
Z 	Clear grid B
J 	Set note duration
G 	Set octave
F 	Play a note
P 	Pause for 0.1 seconds
L 	Loop forever
H 	Halt
== Examples ==
=== Hi ===
Drawing "HI":
MNNWW7SSSMNN7EEEMNW7SSSMEEN7NNNL
=== Bouncing Ball ===
A bouncing ball (evolved screens):
YVA9MNW145NM425WSWMSII12D678I97M8MWWXZB2I6M5IN9I2
499W5989D5E775S5WS45MNEYVAD83281S355NESW89794M6M9
2926D47MNXZB57M9MEMS78I4M46MS6M95D5E5N25WSMNNWYVA
MDIMS5E5S5SMW55NS749I4MD3250W9MSSEXZBW3540SESWM73
5MII75N3298525ES5SMSSYVAEWS56MW6DD4D55SIMI115WNS8
279MEMENNXZB89MDM4I972S5WEM57D5N5645WW2I4IMEEYVA2
D764I319D9112615NEI7876SMM5NEMSWWXZB1835MEN5ENW4S
97D46NIS678DDSM68MWYVA56647MN5E587795NWNMNNS5I331
334MNXZB78MNM4WN7E4MI85S94715W6N15S25SME
=== Radar Sweep ===
An animated radar sweep with "beep" (evolved screens):
YVA5383149W7EE27MEIMEWME4IEM6W74M975W932785MWWPPP
PXZB37N387IM381IMIMW7495N19W645E8M9M4M188ISWMSEEP
PPPYVA852MM7W4699793554MNE6791594415NSI6N42961MSS
PPPPXZBMI57S49173ME83I613MN7MN6E18125IMN95EME5SMS
EPPPPYVA1TJ7TF744299818E488E52I4M66I7M1462I5WW7E1
22IE1MWWPPPPXZB7E42943MSM76S6617EM55WI36M9454I57I
33M50WMNNPPPPYVA527S43M2S127778795N8E45MW57923311
776S277MNNPPPPXZB697SMW6W99857M662M377242MSI83W35
ME2125E1MNNEPPPP
== Computational class ==
Firefly is not Turing complete.
== Implementations ==
* Official interpreter and examples (see videos directory)
Category:LanguagesCategory:2022Category:Implemented
First.go

first.go is a tiny concatenative esolang that User:Zero created to get used to Go, as the creators first Golang program.
==Overview==
===Family===
The language is stack-based concatenative, but it reads backwards. When you type a command, you begin with the bottom of the program stack and you end with the top of the stack: foo dup bar will first push bar on the data stack, then dup it, then push foo on it, so you end up like
 +-----------+
 | foo |
 +-----------+
 | bar |
 +-----------+
 | bar |
 +-----------+
===Data types===
The only data type is strings, the language doesn't even know about numbers or booleans. For booleans, the string "1" means true, and anything else means false. For numbers, we can use the length of words to simulate values, like ||| means 3. Well, since you can do a lot with the programming language Thue, I guess you can do a lot with this one too (we have a "find and replace" function).
===Grouping===
Many concatenative languages use brackets or parentheses to group things and nest them. There's no grouping in first.go, but the underscore characters are always automatically replaced by space characters, which allows easier function definitions. Nesting is byebye though.
===Vocabulary===
The following verbs are available: pop, dup, pick, swap, popd, popop, dupd, swapd, rollup, rolldown, choice, output, input, cons, uncons, append, remove, replace, removeall, replaceall, do, get, set, def, if, ife, and, or, not, equals, contains, prefix, suffix, quote, nothing, space.
==External resources==
* Github readme, which contains the complete first.go manual.
* Compiled windows executable, which accepts a -tron command-line option to show execution steps.
Category:Languages
Category:Stack-based
Category:Implemented
Firstreplace

Firstreplace is an accidental1 esoteric programming language made by Abyxlrz.
(1) It is accidental because i was trying to make a interpreter for the esolang slashes in the programming language smilebasic, but i didn't know how to make all instances of a specific pattern get replaced (the interpreter only replaces the first instance of that pattern).
==Syntax==
The syntax of Firstreplace is very simple. It is similar to slashes' syntax but instead of slashes there are newlines and only the first instance of a specific pattern is replaced. Also the program isn't self modifying, it only modifies the initial state of the program.
It is also possible to allow the program to take input from you. You need to just type [INPUT] in the place of the pattern or replacement, but not the initial state.
 Initial state
 Pattern
 Replacement
 Pattern
 Replacement
 ...
===Example===
 Test
 es
 eses
 Output: Tesest
 ababab
 ab
 cd
 Output: cdabab
==Interpreter==
I, finally wrote my own interpreter. If you have smilebasic 4 then you can download the interpreter.(you can enter the public key 4JDNE22HE)
Category:Languages Category:Total Category:Implemented Category:Unusable for programming Category:Output only
FishScript

FishScript is another fish language made by User:Watermelon3D. It is largely a work in progress.
==Commands==
FishScript is made up of fish and waves in the ocean. The syntax and commands are subject to change.
<nowiki>
<>< Represents one unit of fish.
~ Doubles fish in front of it.
>o Pushes to the stack.
o< Generic stack pop. Prints the ASCII character.
<P>< Peek at the top of the stack. Prints the ASCII character.
<D>< Pop but no print.
<DU>< Duplicate the top of the stack.
<S>< Swap the second and top of the stack.
<O>< Pushes the second item in the stack to the top while still being in the same position.
<V>< Gets input, and pushes to the stack for variables.
<DEF>< Define a function.
<CLOSE>< Close the function definition.
><V> Pop the variable stack.
><F> Pop the function stack (that will be used for different uses, e.g. if statements).
</nowiki>
Any other characters are ignored by the interpreter.
==Examples==
===Hello World===
soon
==Interpreters==
There are a few interpreters, including:
Watermelon3D's reference repo 
Willicoder's repo
Category:Languages Category:2020 Category:Unusable for programming Category:Implemented Category:Stack-based Category:Works-in-Progress
Fish Code

Fish Code is an esolang invented by User:None1. It is named Fish Code because its programs are shaped like fish.
==Syntax==
Every line in Fish code must be like this.
 <COMMANDS><
When executed, a program starts from the first line, if a jump command isn't executed in one line, the program terminates.
==Commands==
Fish code uses 2 byte stacks and a byte register.
The byte register is initially 0, the stacks are initially empty.
It doesn't matter which stack is the current stack initially, since that wouldn't affect the behavior of the program.
Overflow and underflow wraps around.
Command	Meaning
+ 	Increment register
- 	Decrement register
, 	Read a character and store it in the register
. 	Print register as ASCII
: 	Read register as decimal
; 	Print register as decimal
? 	Pushes the value of register into the current stack
! 	Pops from the current stack and store it into register
~ 	Switch current stack
(A) 	If the register is zero, jump to line A
[A] 	If the register isn't zero, jump to line A
{A} 	Jump to line A no matter what
((x)) 	Set the register to the value of x (a number)
(((x)))	Subtract the value of register by x
Programming in Fish Code is easy because it has more commands, but complicated because you have to manipulate the loops yourself.
==Example Programs==
===Hello World===
 <((72)).((101)).((108)).((108)).((111)).((32)).((87)).((111)).((114)).((108)).((100)).((33)).><
===Cat Program===
 <,.{0}><
Note: The first line is line 0.
===Truth Machine===
 <,(((48)))(1)[2]><
 <(((208))).><
 <(((208))){3}><
 <.{3}><
===Reverse Cat Program===
 <?{1}><
 <,(((10)))[2](3)><
 <(((246)))?{1}><
 <![4]><
 <.[3]><
===Nope. Interpreter===
 <((78)).((111)).+.((101)).((46)).><
===Infinite loop===
 <{0}><
==Turing completeness==
The language is Turing complete since we can use two stacks to simulate a brainfuck tape, and use the jump commands to simulate brainfuck loops.
==External Resources==
* Interpreter in Python
Category:Languages
Category:Turing complete
Category:Implemented
Category:Stack-based
Category:2023
Fishheads

Fishheads is an esoteric programming language based on Deadfish and Deadfish~ made by _hyperdawg. Fishheads implements the same functions as Deadfish, however, it implements ASCII output and user input. The latest version is available on GitHub .
=Commands=
i	Increments the accumulator
d	Decrements the accumulator
s	Squares the accumulator
o	Outputs the accumulator as an integer
c	Outputs the ASCII character associated with the accumulator
g	Gets user input in integer form and assigns the accumulator to it
r	Resets the accumulator
h	Halts the program or shell
l	Clears the console
=Example programs=
===Hello World===
riiiiiiiiiisiiiicdddciiiiiiicciiicriiiisiiiiiiiiiiiiiiiicriiiiiiiiiisiiiiiiiiiiiiiiiiiiicddddddddciiicddddddcddddddddc (outputs "hello world")
===Cat program===
go
==Interpreter==
* Common Lisp implementation of the Fishheads programming language.
Category:Languages
Category:Finite state automata
Category:Joke languages
Category:2021
Category:Unusable for programming
Category:Implemented
Category:Total
Fishstacks

Fishstacks is a Deadfish derivative which uses a stack; the stack can only hold four elements, when a fifth element is pushed the bottom element is kicked out and eventually printed out to the screen. The name was originally meant to be Hpmestack but it was suggested that DeafStack or StackFish would be a better name, as it is a derivative, but eventually atriq came up with Fishstacks.
==The Stack==
First of all it is to be noted that the above specification were meant to be written in 30 seconds. However the language author accidentally set his timer to 30 minutes instead, and it took him about one whole minute to realize that. Unfortunately the extra time wasn't enough for him to think about including a "pop" function, so the "push" function is really just "set the accumulator to 0". No, it's slightly more *cough* subtle than that; "setting the accumulator to 0" has the side effect of causing the previous value of the accumulator to be pushed to the output queue. Happily for everyone the language wasn't called "Dequefish"...
As a side note the 30 minutes timer rang just before this page was saved.
==The Commands==
Command	Effect
i 	Increment top element
d 	Decrement top element
p 	Push a new zero to the stack.
s 	Square top element
If there were already four elements in the stack, and the command p is used, the bottom element is outputted and discarded.
Needless to say, Fishstacks's arithmetic is expected to be as ingenious as Deadfish's; whenever the top element reaches -1 or 256 the top element is set to 0, as if the command p was used. This means Fishstacks is more powerful than its predecessor Deadfish: not only does it have a whole stack instead of a lone accumulator, but it can output two more different values!
==Examples==
User:Killer64 had too much time on his hands and wrote "Hello, World!".
iiisdsiiiiiiiipiiisisipiiisisiiiiii
iipiiisisiiiiiiiipiiisiisdddddddddd
piiisddsdddddpiisiisddddpiiissiiiii
ipiiisiisddddddddddpiiisiisdddddddp
iiisisiiiiiiiipiiisispiisiisdddpppp
==About the authors==
User:Koen refuses to take full responsibility for this language; User:Taneb is guilty for the name, User:monqy is glad that now he can use this language to write a program, and User:nooodl provided meaningful insights about the semantics.
==External resources==
* #esoteric logs of the language creation.
* Fishstacks interpreter in C#
Category:Languages
Category:Joke languages
Category:Stack-based
Category:Push-down automata
Category:Implemented
Category:Total
Category:Output only
Category:Unusable for programming
Fist

Fist is an esolang created by User:Viba. Its name is derived from "Finite State", as Fist is merely finite state machine equivalent. It is effectively a more compact form of their earlier esolang FakeScript.
== Description ==
Each line is a command. The following commands exist:
 Commands
Command	Description
.X 	Outputs string X.
? 	Accepts input as a string.
X>Y 	If the previously accepted input is equal to X, jump to label Y. If X is an empty string (ie. >Y), jump to label Y unconditionally.
:X 	Declares a label identified as X.
The program halts after the bottom of the program is reached.
== Examples ==
=== Hello, world! ===
 .Hello, world!
=== Truth-machine ===
 ?
 0>0
 1>1
 >hlt
 
 :0
 .0
 >hlt
 
 :1
 .1
 >1
 
 :hlt
===+ interpreter===
 :c
 ?
 +>+
 >c
 :+
 .+
 >c
It is can be implemented, because it is language with only "Push" command
===Nope. interpreter===
 ?
 .Nope.
===Logic Gates===
====NOT====
 ?
 0>0
 1>1
 :0
 .1
 >end
 :1
 .0
 :end
====AND====
 ?
 0>0x
 1>1x
 :0x
 ?
 1>0
 0>0
 :1x
 ?
 1>1
 0>0
 :0
 .0
 >end
 :1
 .1
 :end
====OR====
 ?
 0>0x
 1>1x
 :0x
 ?
 1>1
 0>0
 :1x
 ?
 1>1
 0>1
 :0
 .0
 >end
 :1
 .1
 :end
====NAND====
 ?
 0>0x
 1>1x
 :0x
 ?
 1>1
 0>1
 :1x
 ?
 1>0
 0>1
 :0
 .0
 >end
 :1
 .1
 :end
====NOR====
 ?
 0>0x
 1>1x
 :0x
 ?
 1>0
 0>1
 :1x
 ?
 1>0
 0>0
 :0
 .0
 >end
 :1
 .1
 :end
====XOR====
 ?
 0>0x
 1>1x
 :0x
 ?
 1>1
 0>0
 :1x
 ?
 1>0
 0>1
 :0
 .0
 >end
 :1
 .1
 :end
====XNOR====
 ?
 0>0x
 1>1x
 :0x
 ?
 1>0
 0>1
 :1x
 ?
 1>1
 0>0
 :0
 .0
 >end
 :1
 .1
 :end
===+- interpreter===
 :code
 ?
 +>+
 ->-
 #>end
 :+
 .1
 >code
 :-
 .0
 >code
 :end
Uses # to end the program. Counter value is numbers of 1 outputed - numbers of 0 outputed
== External resources ==
* Online JavaScript interpreter
* Compiler for Fist with different syntax
Category:Languages
Category:2022
Category:Finite state automata
Category:Implemented
Fit

Fit is an esoteric programming language by User:Madk which uses numbers in base 5 (termed 'fits') to compute things. Each fit contains a number from -2 through +2 inclusive.
==Commands==
 +	rotate current fit digit; -2 → -1; -1 → 0; 0 → 1; 1 → 2; 2 → -2
 -	rotate fit backwards
 ~	negate fit
 (	jump past the corresponding ) if the current cell = 0
 )	jump back to matching ( if the current cell is ≠ 0
 {	jump past matching } if the cell is ≥ 0
 }	jump back to { if the cell is < 0
 [	jump past matching ] if the cell is ≤ 0
 ]	jump back to [ if the cell is > 0
 /	jump past matching \ if the cell is ≠ 0
 \	jump back to / if the cell is = 0
 ?	skip the following instruction if the current cell is = 0
 !	skip the following instruction if the current cell is ≠ 0
 ^	skip the following instruction if the current cell is > 0
 v	skip the following instruction if the current cell is < 0
 =	destroy the current cell, following cell takes place under the pointer and all following cells are shifted left once to fill the gap
 <	move cell pointer left
 >	move cell pointer right
 _	set the ASCII byte counter to 0
 ,	add the current ternary cell to the ASCII byte counter
 ;	output the ASCII byte counter, which is always 59 (the ASCII value for the character ;) at program start
 n	output a newline
 .	output the number under the pointer
 :	get input for the number under the pointer
 #	begin/end comment
==Examples==
===Hello, world!===
 ++,,,,,,-,;_+,,,,,,'+,-'-,;,+,,,;;,-,;_+,,,,';_,';+,,,,+,;-,,,,;-,-,;++,,,;,,,,;_-,'-,;
===Cat===
 +[>:.n<]
===Quine===
 ;
==Computational class==
Fit is turing-complete by reduction from Boolfuck, which reduces from its parent language brainfuck.
Boolfuck function	Fit commands
> 	>
< 	<
[--]+ 	
[ 	(
*] 	*)
* : Equivalent control flow
==External resources==
Download Fit interpreter
Category:Languages
Category:Cell-based
Category:Implemented
Category:Low-level
Category:2011
Category:Turing complete