nyuuzyou/wikis huggingface dataset:
Feather

According to information revealed by time travelers, the esoteric language Feather exists in some hypothetical futures, and will be made by User:ais523. However in other futures the mere idea has caused him to go completely insane before he could make it, while in others again he has kept some of his sanity by indefinitely abandoning the concept. It still remains to be seen which future will be realized in our own timeline, although so far evidence sadly seems to point to the third option.
Crude shadows of the protoideas of Feather may be picked up by people willing to risk browsing logs of the #esoteric IRC channel. The most relevant log is probably this one, in which ais523 explains pretty much the entire known state of Feather development. It's important to note that most (all?) details of the language have not been pinned down; the attempt is more to find anything that works, rather than to implement a specific specification. ais523 subsequently clarified the main issues plaguing Feather here.
Here's an excerpt where ais523 explains the origins and basic idea of Feather (believe it or not, it's inspired by Smalltalk):
{| class="plainpres"	
<ais523>	[...] anyway, the problem with Smalltalk is that you have to have a heavyweight OS-like thing to get anywhere with it
<ais523>	because of all the everything defined in terms of everything else and needing a really expansive environment to do things
<ais523>	like having class objects for regular objects, and ability to method browse, and so on
<ais523>	and the result of /that/, is that Smalltalk programs aren't portable
<ais523>	following me so far?
[...] 	
<ais523>	basically, the common way to distribute a Smalltalk program is just to bundle the entire VM image
<ais523>	because you can't do it any other way
<ais523>	now, to solve this problem, you need to do two things: a) allow the language to be entirely written in itself, going back forever (solves the portability problem), and b) allow the VM state to be recreated from scratch by running a sequence of instructions (basically, libraries, followed by the program)
<ais523>	I don't think a) is solvable, while remaining computable, but you can fake it using retroactive changes
<ais523>	the main reason behind retroactive changes, though, was to get around the need to have separate classes and objects
<ais523>	in Smalltalk, you can alter a class in order to change all objects spawned from it
<ais523>	in Feather, you create objects by cloning+modification, and if you retroactively change the parent object, that changes all its decendants, so it comes to the same thing
Feather subsequently became something of an inside joke in #esoteric, due to ais523 refusing to talk about the details, and yet still insisting that the language was real, just he couldn't make it work and refused to think about it in order to avoid going mad (and recommends other people do the same).
Category:Self-modifying Category:Unimplemented Category:Languages
Feedfish

It simulates how hard it is to feed a fish: A fish can't know if it is full or not, so if you give it more food when it is full, it will still eat the food.
==Memory==
Like deadfish, there is an accumulator, but the accumulator has two properties: value and energy. The energy is initially 3, if the energy becomes more than 3 or less than 1, the program will error.
==Commands==
It has one more command than deadfish: f, it increases the energy of the accumulator by 1. For every non-f command starting from the first command, the accumulator's energy is decreased by 1 after the command is executed.
==Examples==
===XKCD Random Number===
 iififfio
==Interpreters==
===Python 3===
"""
Modified from the Deadfish Python interpreter by User:Tux1
"""
accumulator,energy = 0,3
while True:
 command = input(">> ")
 if accumulator == 256 or accumulator == -1:
 accumulator = 0
 if command == "i":
 accumulator += 1
 energy-=1
 elif command == "d":
 accumulator -= 1
 energy-=1
 elif command == "s":
 accumulator **= 2
 energy-=1
 elif command == "o":
 print(accumulator)
 energy-=1
 elif command == "f":
 energy+=1
 if energy<1 or energy>3:
 raise RuntimeError('Your fish is dead!')
Category:Languages
Category:Joke languages
Category:2024
Category:Implemented
Category:Total
Category:Deadfish derivatives
Category:Output only
Feta

==Overview==
Feta is a joke programming language created by Nicholas Smith as a glitch to the BBC question about false programming languages on 30 May, 2013. It contains only one instruction: "WRITE", that prints "H3110 W0R1D" in an external text file named "0WTPWT.txt". It was designed to be an April Fools Joke on the GlobalGameDevelopersForum site.
==Syntax==
Syntax is very simple: The one instruction allowed "WRITE".
==Example==
 WRITE
==Implementation==
Zayne was here and this is his implementation
 i = input("Enter Command: ")
 if i != 'WRITE':
 print("")
 else:
 file = open("0WTPWT.txt","w") 
 file.write("H3110 W0R1D")
 file.close()
And, User:A was here and this is his implementation(in C++):
 #include <bits/stdc++.h>
 int main(){
 freopen("0WTPWT.txt","w",stdout);
 char code[1000];
 scanf("%s",&code);
 if(code=="WRITE")printf("H3110 W0R1D");
 fclose("0WTPWT.txt"); 
 return 0;
 }
And... User:BadBoyHaloCat presents to you... Feta.js
 const fsp = require('fs').promises;
 
 (async () => {
 let code = await fsp.readFile(process.argv[2], 'utf-8');
 if (code.includes("WRITE")) await fsp.writeFile('0WTPWT.txt', 'H3110 W0R1D');
 })();
Here is User:masalt's Feta implementation:
 while True:
 i=input(">> ")
 if i=='WRITE':
 file=open("0WTPWT.txt","w") 
 file.write("H3110 W0R1D")
 file.close()
==See also==
* Pizza
Category:Joke languagesCategory:ImplementedCategory:2013Category:Output onlyCategory:Unusable for programmingCategory:Languages
Fetch

Fetch is a programming language made by User:masalt
==Examples==
===Hello, World!===
 Throw Hello, World!
 Fetch 13
 Drop
===Fibonacci Sequence===
 Throw 1
 Count
 Throw 1
 Count
 Fetch 1
 Drop
 Fetch 1
 Drop
 
 Up A
 Walk 2
 Fetch 1
 Drop
 Down A
===Cat===
 Up A
 Bark
 Fetch All
 Drop
 Down A
Fetlang

Fetlang is a statically typed, procedural, esoteric programming language and reference implementation. It is designed such that source code looks like poorly written fetish erotica.
Fetlang is not recommended for production use at this moment, especially in medical or military applications. However, that does not limit one from possibly implementing it in said applications.
==Example==
The following example outputs the arguments given to the executable (comments are in parentheticals):
 (Set Sean to an empty chain)
 Make Sean moan
 
 (Set Carrie to 0(a fraction))
 Worship Carrie's feet
 
 (Have Amy cycle through a chain listing arguments given, separated by '\0'(a fraction))
 Bind Amy to Saint Andrew's Cross
 
 (Add Amy(a fraction) to Sean)
 Have Amy hogtie Sean
 
 (If Amy is '\0', print out the current argument, and reset Sean)
 If Amy is Carrie's bitch
 Make Slave scream Sean's name
 Make Sean moan
==Computational class==
Fetlang has shown to be Turing-complete by this Rule 110 implementation.
==Features==
* Input/output with standard streams and files
* Statically typed
* Gendered variables
* Access previously mentioned variables using pronouns
* Numbers represented internally as fractions instead of floating point
* Transpiles to C
* Case insensitive
* Confusing English-like syntax and unhelpful error messages
* Probably Turing complete
* Extensible - just install your fetish in share/fetlang/fetishes
==External resources==
* Github Repo
Category:Implemented
Category:Turing complete
Category:Languages
Category:Joke languages
Category:Pseudonatural
Category:Thematic
Fetus

Fetus is a Starstuff language by User:PixelatedStarfish. It uses a Starstuff compiler to convert any file into runnable bf code. Apart from that, there is not much more to say about it that has not already been written in other articles. However, it is notable that anyone can write Fetus code, even if they insist they cannot write code, and that its too hard. Any file that is converted to the .fetus type is valid Fetus source code. This is a property of the language that remains true, no matter how many previous bad experiences a programmer-to-be has had in coding courses of one kind or another.
Category:Languages
Fi (Archived)

Fi is a conceptual programming language by User:Rdococ.
Notable features of Fi would include:
* A strong, but implicit type system, which would include something like Bosque's string types, a separate system of number types to represent measurement quantities and units, and possibly more.
* A deterministic, region-based memory management system. Regions are automatically allocated when the program enters a scope, and deallocated when it leaves, and values are automatically allocated to the shortest-lived region that contains their entire possible lifetimes.
* Mutable variables and loops which follow certain restrictions so that they may be converted into a purely functional form for static analysis.
A more detailed description is currently a work in progress.
Category:Languages Category:Unimplemented Category:Turing complete
Fibonacci sequence

The Fibonacci sequence is a sequence of numbers, called Fibonacci numbers, where each number is the sum of the two previous numbers in the sequence. The only exception is the first two numbers which are 0 and 1. 
Formal definition:
 F(0) := 0
 F(1) := 1
 F(n) := F(n - 2) + F(n - 1) where n > 1
Writing a program that calculates Fibonacci numbers is a popular problem when trying out a new esoteric language, or for showcasing its features.
==See also==
* Project Euler Problem 2, a problem that has something to do with Fibonacci sequence.
==External resources==
*Fibonacci sequence on Wikipedia
* Fibonacci sequence on Rosetta Code
Category:Program forms
Figurehead

Figurehead is a minimal esolanguage designed by Keymaker. The language was formed while the author was designing another language, and once the idea for Figurehead struck, the other one was abandoned. The language uses two characters, "|" and " ", and a memory that's mostly accessed as a stack. Programs can only consist of the two characters, everything else is forbidden. Only sequences of two or more of the same character are counted, that is, only they cause computation to happen. Sequences of one character may be used to distinguish different sequences from each other. The memory is unbounded and infinite.
==Instructions==
"|"-sequences (starting from "||") form a value that is pushed to the right end of the memory. For example "|||" would push "|||" or 3, however you want to see it, into memory.
" "-sequences (starting from "  ") form loops, and need a matching part. Loops may be nested, and an identical loop sequence used later. Once a loop is encountered, the rightmost value is popped from the memory (an empty memory results in an error), and the memory loops as long as there are instances of the value indicated by the value that was popped, and whilst looping one instance is removed from the memory at the beginning of each cycle, the instance chosen by moving from left to right in the memory (to keep the language deterministic). It is also possible for a loop to be executed zero times (not at all, in other words).
==An example==
As an example, let's have the following program:
 || || || ||| |
The last "|" is not necessary but it's included to avoid problems with the wiki cutting out trailing spaces. Anyway, the program begins by pushing "||" into memory three times. Then a loop. Memory is popped, and there are two instances of "||" left. That is more than zero, so the loop may begin. On each cycle one "||" is removed from the memory, thus the loop will be executed twice. On each time "|||" is pushed into memory. The state of the memory after the program is finished is two "|||" values.
==Computational class==
The language is Turing-complete. It's easy to have infinite values stored in it (decoded as amount of instances of certain values), and thus it's easy to create any unbound number of registers with any natural number as their capacity. Minsky Machines, which are Turing-complete, can be translated into Figurehead, proving its Turing-completeness. (This is done explicitly, too. See the external Figurehead page.)
==External resources==
* Figurehead page (specs, programs, interpreter, Minsky Machine to Figurehead compiler)
Category: Turing tarpits
Category: Turing complete
Category: Low-level 
Category: Languages
Category: No IO
Category: Implemented 
Category: 2008
Fiifinite

Fiifinite is a FSM but the only change is a state can split the pointer into to! now this may seem boring but this is equal to creating a copy program making in an infinite state machine. but really its just a infinite pointer finite state machine(IPFSM)
== syntax and semantics ==
to create a state x that trantitions to state y:
 x -> y
now if you want to split the pointer making it go to multiple states (say x splits and goes to y and z):
 x *-> y *-> z
the empty state will always halt
every state must be defined on seperate lines. if a state is ncased by square brackets every time a pointer goes to it the name will be printed(no newline). first line state is the one the pointer starts at
== examples ==
Truth-machine:
 i -> x
 1 *-> 1 *-> 11
 [11] -> 11
 0 -> 
where x must be replaced with the input.
Category:Languages Category:Unimplemented Category:2024
FileCode

A weird programming language that explains using files to do the work for the interpreter. (No interpreter yet)
It has weird files on your computer that only FileCode understands the extension of.
You must use & and not a new line to separate commands.
It is for experimenting, and it is created by User:Rdococ.
A program that fiddles with variables, and explains the use of comments: (Beware: This is quite hard to learn!)
/programinterept.int inputs "
/var/new/varcreate.vc inputs "var" & /var/increment/increment.scr inputs "var" "2" & /var/decrement/decrement.scr inputs "var" "2" & /!This is a comment!/ & /comment/add/create.scr inputs "This is the equlivent to the comment before this command" & /var/increment/increment.scr inputs "var" "1" & /var/increment/increment.scr inputs "var" "3" & /!The above does 2 commands one after another, used with the if command!/ & /if/equal.bo inputs var "2" /var/increment/increment.scr inputs "var" "2" & /!Comments on it's own!/" "
==Other commands==
A list of other commands.
===Reporters===
/report/answer.re 
/join.re inputs "Join this" " and this together!"
===Printing===
/print/print.scr inputs "I print this."
===Asking for no apparent reason===
(scrboc means Script/Command as Boolean Counterpart)
/noreason/ask/ask.scrboc
===Deleting a variable===
/var/del/delvar.vd inputs "varname"
===Ending a program===
/endprogram.exi inputs "programinterept.int"
===Starting a program's scripts===
(if not placed, error will show up)
/programminginterept.int inputs "codehere"
===Other booleans===
/not.bo inputs "equal.bo inputs "2" "2" "
/equal.bo inputs "2" "2"
/lessthan.bo inputs "2" "1" 
/morethan.bo inputs "2" "3"
/questionanswer.bo inputs "Do you exist?" "Yes."
[!] Please take time to edit this page to include a link to a bigger description—I'm lost here!
Category:Languages Category:Unimplemented Category:2011
FileSys

==Overview==
FileSys is a language which stores and manipulates all of its variables as files on the file system instead of in memory locations in the traditional sense.
==Syntax==
===Files===
There are four valid file types in the FileSys language
* .a - String data in ascii format
* .n - Numeric data in arbitrary precision decimal data
* .b - Block, an empty file used for signalling between threads or processes
* .f - A script of FileSys commands to be executed
===Operations===
Operation	Explanation 	Syntax 	Example
mkdir 	Makes a new directory for storing variable files	mkdir <path> 	mkdir /var/data
out 	Write data to file 	out > <path>	out 12345.67 > /var/data/bank.n
in 	stub 	stub 	stub
mv 	stub 	stub 	stub
chmod 	stub 	stub 	stub
watch 	stub 	stub 	stub
exec 	stub 	stub 	stub
add 	stub 	stub 	stub
sub 	stub 	stub 	stub
mul 	stub 	stub 	stub
div 	stub 	stub 	stub
jumpz 	stub 	stub 	stub
halt 	stub 	stub 	stub
===Script Format===
 :<label>:
 <command> <args>+
==Examples==
===Hello World===
 mkdir /var
 out "Hello World" > /var/message.a
 echo /var/message.a
==Grammar==
 <line> ::= <label> | <statement>
 <label> ::= ":" <string> ":"
 <statement> ::= IN | OUT | MKDIR | MV | CHMOD | EXEC | WATCH | ADD | SUB | MUL | DIV | JUMPZ | HALT
 <string> ::= <char> | <char> <string>
 <char> ::= (a-zA-Z0-9)
==See also==
*Dirst
Category:Languages
Filename "xxx" doesn't seem to be a valid filename. Please check if the filename your trying to execute is written correctly

Filename "xxx" doesn't seem to be a valid filename. Please check if the filename your trying to execute is written correctly or WDS File error is an esolang inspierd by dmc, hasB, llehsrewoP and SOD-SM made by User:Ractangle.
==Syntax==
Typing anything in the input will emit this:
 Filename "input" doesn't seem to be a valid filename.
 Please check if the filename your trying to execute is written correctly
And that's basicly it.
Also that error message came from a fictional DOS
==Interpriters==
===Python===
Golfed:
while 1:print(f'Filename "{input()}" does not seem to be a valid filename.\nPlease check if the filename your trying to execute is written correctly')
Not Golfed:
 while True:
 i=input()
 print(f'Filename "{i}" does not seem to be a valid filename.\nPlease check if the filename your trying to execute is written correctly')
Category:Languages Category:2024 Category:Joke languages Category:Implemented Category:Total Category:Output only
==See also==
* bash: foo: No such file or directory
* foo : The term 'foo' is not recognized as the name of a cmdlet, function, script file, or operable program. Check the spelling of the name, or if a path was included, verify that the path is correct and try again.
* Bad command or file name
* Filename "main.sl" doesn't seem to be a valid filename. Please check if the filename your trying to execute is written correctly Old name for Bake
FilesAndFolders!

FilesAndFolders! (FAF!) is a esoteric programming language created by LDRK11. FAF! isn't a normal esolang that you just pass a file for the interpreter to read. Instead FAF! as the name suggests, uses folders (and sometimes files). An interpreter in TypeScript is available on GitHub: https://github.com/ldrk11/FilesAndFolders.
== Folder Structure ==
When FAF! reads a folder it gets sorted by alphabetical/numerical order. For example, if you had a folder like this:
 SetValueStr
 Hello World
 Print
It wouldn't work because Print would run first. However if you had something like this:
 1SetValueStr
 Hello World
 2Print
It would run SetValueStr first then Print would print it
== Commands ==
0 Args means use as a file or empty folder
Command 	Description 	Args (files/folders)
Print 	Prints the working value 	0
PrintAscii 	Gets the working values ascii character and prints it 	0
Input 	Takes input and sets the working value to the result 	0
InputNum 	Takes input and sets the working value to the result (As number) 	0
Pop 	Pop most recent item in stack and sets it as the working value 	0
Push 	Push the working value to the top of the stack and emptys the working value 	0
Delete 	Same as Pop command but doesn't set the working value 	0
Copy 	Same as Push command but doesn't empty the working value 	0
Duplicate 	Duplicate the top value on the stack 	0
Add 	Pop and Add top 2 values on stack and sets the working value to the result 	0
Subtract 	Pop and Subtract top 2 values on stack and sets the working value to the result	0
Multiply 	Pop and Multiply top 2 values on stack and sets the working value to the result	0
Divide 	Pop and Divide top 2 values on stack and sets the working value to the result 	0
Modulo 	Pop and Modulo top 2 values on stack and sets the working value to the result 	0
IfSkip 	Skips past the next command unless the working value is negitave or 0 	Infinite
If 	Runs code inside folder unless the working value is negitave or 0 	Infinite
Goto 	Gets the number in the file then goes to the folder/file with that number 	1
End 	Ends program 	0
SetValueStr	Sets working value to the file (As string) 	1
SetValueNum	Sets working value to the file (As number) 	1
Shift 	Pops the top value of the stack and pushes to the bottom 	0
NewLine 	New line in console 	0
== Examples ==
=== Cat ===
 1Input
 2Print
=== Truth Machine ===
 1Input
 2If
 3Print
 4Goto
 3
 3Print
Category: 2024
Category: Stack-based
Category: Languages
Final Word Of The Day

Final Word Of The Day is an esolang that you cant program in. yet. this is because Final Word Of The Day is an esolang that you must solve for. it was created by User:Yayimhere
== Properties ==
These are the properties of FWOTD (Final Word Of The Day):
* there is only one Quine (excluding programs that are Rotary Quines) for FWOTD, but infinite Narcissists
* FWOTD has no Rotary Quines (with no commands that doesn't affect the output) that wouldn't be the same as two FWOTD commands (this would not be true if FWOTD was not turing-complete)
* FWOTD is turing-complete
* every FWOTD command put as the input to another FWOTD command is the same as the third FWOTD command. this rule does not apply to commands that are derived from this (otherwise, FWOTD would have infinite commands)
* FWOTD has no Self Interpreter that does not have the side effect of being a Narcissist
* Looping counter up to Infinity cannot be implemented in FWOTD without it being ran in a Self Interpreter
==See also==
* Final Word Of The Day/PkmnQ
Finif

Finif is a joke language created by User:Rootflier102 that is a simple esoteric language with some complex elements.
It's not really an esoteric language, as Finif is more of a regular programming language.
== Syntax ==
Syntax is divided into four parts: Prefix, Condition, Action, and Suffix.
* The order of syntax goes like this: "On (Prefix) by (Condition), do (Action) and end with (Suffix)." It's basically similar to the puzzle game Baba is You, except it's different.
* The prefix is the start of syntax, aka the "starter". It's required to run a block of syntax code.
* The condition is basically a condition; A block of syntax can only run if it meets the condition.
* The action is the result of a condition/prefix. It can be used to execute scripts or macros, for example.
* The suffix is the end of syntax, aka the "stopper". It's required to stop a block of syntax code.
For example: the command "require" has to require something or else it won't work. Only works for (Condition) -> (require.examplescript).
Colons (:) describe a variable or property of something. Works for any syntax. Example; (pyscript.function.near:line17) / (code.debug.near:eof)
== Examples ==
Here are some examples, if you're confused:
on (pyscript.execute) by (require.pyscript) do (pyscript.function) and end with (pyscript.close) -- Python script execution
on (hashing.init.run) by (require.hashing) do (hashing.decode) and end with (hashing.stop) -- To decode something using hashing
on (hashing.init.run) by (require.hashing) do (hashing.decode.base:val32) and end with (hashing.stop) -- Decoding Base32 using hashing