nyuuzyou/wikis huggingface dataset:
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.

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. or simply llehsrewoP is an esolang created by User:None1 and inspired by bash: foo: No such file or directory, it imitates a common Powershell error when you attempt to execute a command that does not exist.
==Commands==
Every command is valid, and prints:
[command] : The term '[command]' 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.
==Interpreter==
===Python===
[print("{} : The term '{}' is not recognized as the name of a cmdlet, function, script file, or operable program.\nCheck the spelling of the name, or if a path was included, verify that the path is correct and try again.".format(x,x)) for x in __import__('sys').stdin.read().split('\n')]
===C===
The program implements a REPL, and uses the insecure function gets to read the program.
#include<stdio.h>
char _[1000000];int main(){while(!feof(stdin)){printf("PS C:\\>");gets(_);printf("%s : The term '%s' is not recognized as the name of a cmdlet, function, script file, or operable program.\nCheck the spelling of the name, or if a path was included, verify that the path is correct and try again.\n",_,_);}}
===Batch===
@echo off
:bad
set /p x=PS C:\^>
echo %x% : The term '%x%' is not recognized as the name of a cmdlet, function, script file, or operable program.
echo Check the spelling of the name, or if a path was included, verify that the path is correct and try again.
goto bad
==See also==
* bash: foo: No such file or directory
* 'xxx' is not recognized as an internal or external command, operable program or batch file., another similar esolang.
* Bad command or file name, another similar esolang.
P.S.: It's the language with the second longest name on this wiki (213 characters), the longest is BF+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ (255 characters).
Category:Languages
Category:Joke languages
Category:Unusable for programming
Category:Output only
Category:Total
Category:2023
Category:Implemented
Foo machine

Foo machine is a hypothetical machine created by Leo Tenenbaum in order to demonstrate that determining whether a simpler machine than the Turing-machine halts is possible.
==Reference==
Determining whether a Turing machine halts is well known to be undecidable, but that's not necessarily true for simpler machines.
A Foo machine is a machine with a finite tape, where each cell on the tape has an integer or the halt symbol h, e.g.
2 h 1 -1
The instruction pointer starts by pointing to the first cell:
2 h 1 -1
^
At every step, the instruction pointer moves forward by the number it points to, then negates that number. So, after one step, it would move forward 2 cells, and turn the 2 into a -2:
-2 h 1 -1
 ^
The Foo machine keeps doing this until the instruction pointer is pointing to the halt symbol (h). So, here is the full execution of this program:
2 h 1 -1
^
-2 h 1 -1
 ^
-2 h -1 -1
 ^
-2 h -1 1
 ^
-2 h 1 1
 ^
The tape is also circular, so if the instruction pointer moves off of one side of the tape, it goes to the other side, e.g.:
3 h 1 3
^
-3 h 1 3
 ^
-3 h 1 -3
 ^
-3 h -1 -3
 ^
-3 h -1 3
 ^
3 h -1 3
 ^
One interesting thing about these Foo machines is that some do not halt, e.g.:
1 2 h 2
^
-1 2 h 2
 ^
-1 -2 h 2
 ^
-1 -2 h -2
 ^
-1 2 h -2
 ^
-1 2 h 2
 ^
This program will continue looping in those last four states forever.
Category:2019
Foobar and Foobaz and Barbaz, oh my!

:For the definition of the word foobar, see Wikipedia:Foobar
Foobar and Foobaz and Barbaz, oh my! is a simple esolang by User:Ihope127. The syntax is as follows:
 Statement: "<identifier> and <identifier> and <identifier>, oh my<variable>"
 Identifier: A nonnegative integer or a variable
 Variable: "!" or "?" or "." or "..."
A statement of the form "A and B and C, oh myD" calculates ((A and B) or (C and D)) and stores the result in D.
? is a special variable in that reading from it produces input from the user rather than ?'s value, thus making ? effectively read-only as a variable. Likewise, . produces output, and though it can be used as a normal variable, anything written to it is also output to the screen. ... is also special: it's the instruction counter. In fact, only ! is a "normal" variable at all.
An example program:
 ? and 255 and 0, oh my.
 0 and 0 and 0, oh my...
First, user input (?) is AND-ed with 255, which, assuming input is done with ASCII (for Unicode, use 2097151 instead of 255), simply returns ?. Then whatever is stored in . is AND-ed with 0, which will always produce 0. Then we are left with (? or 0), which produces ?. This value is then stored in ., thus outputting it. Next, "0 and 0 and 0, oh my..." is executed. Since 0 and anything is 0, this reduces to (0 or 0), which is 0, a value which is then stored in ..., producing a jump back to the first instruction.
Assuming input is bounded from the start, Foobar and Foobaz and Barbaz, oh my! is a finite-state machine with memory that is bounded at runtime, that is, a programmer can have as much memory as they want, but they have to choose a value and stick with it while running the program.
ihope says the purpose of this language was to find out what the original phrase was.
A sample program that demonstrates Foobar's "switch instruction" can be found in the external resources section. It is 512 lines long, and half of it consists of the "jump bank" used for switching. Since all the information you need has to be stored in a single variable, and each case has to be tested separately (INTERCAL's operators would actually come in quite handy here), a "real" Foobar program has the potential to be extremely long. Nevertheless, this should be proof that Foobar is usable.
A cat program, which handles EOF=-1 is as follows:
 ? and 255 and 0, oh my!
 ! and 255 and 0, oh my.
 ! and -1 and 0, oh my...
 (followed by 249 copies of '0 and 0 and 0, oh my...')
==See also==
* Experimental implementation by User:Sgeo
==External resources==
* Example program in the Esoteric File Archive
Category:Languages 
Category:Finite state automata 
Category:Implemented 
Category:Low-level 
Category:2005
FoolFuck

FoolFuck is an extension of BrainFuck by User:None1. It can write normal programs, but it can also be used to write programs that badly damage the user's computer. It is mainly used in Windows.
==Extended Commands==
There are these extended commands (case sensitive).
Command 	Meaning
Y 	Start another process that runs the program itself
M 	Allocate 1MiB of memory
S 	Shut down the computer instantly
T 	Let this program start at startup
C"Message" 	Create a message box showing the text Message
D 	Delete the program
A 	Press Alt+F4
W 	Hide the console window
P"Executable"	Start the Executable
==Examples==
DON'T run these programs in your computer unless you're using a virtual machine!!!
===Fork bomb===
 +[Y]
===Self deletion===
 D
===Shut down the computer===
 S
===Unclosable message box===
 +[C"Hello World!"]
This creates a message box with the text Hello World!, the message box is unclosable because every time the user attempts to close it, an exactly the same message box will appear.
===Press Alt+F4 infinitely===
 W+[A]
===Allocate memory infinitely until the computer dies===
 +[M]
===Infinite command prompt window===
 +[P"cmd"]
===Let the user's computer shut down when it starts up===
 TS
Category:Languages
Category:Joke languages
Category:Turing complete
Category:Brainfuck derivatives
Category:2023
Force of Arch

Force of Arch is Arch-based language by User:ChuckEsoteric08, which is mix between BF and Data structure Arch.
==Commands==
Command	Function
POINT x	Point to integer x
SPLIT x	Split current element pointed by pointer
ADD x 	Add x to integer pointed by pointer
SUB x 	Same as ADD, but subtract
WHILE 	Back to matching END if integer that pointed by pointer is zero
END 	end loop
PUSH 	Push 0 to element pointed by pointer
POP 	Pop pointed element
==Computational class==
Force of Arch is NOT Turing-complete, because it uses Arch as data. So it is Bounded-storage machine
Category:Languages Category:Bounded-storage machine Category:Output only Category:Unimplemented
Foresolang

Foresolang is an 8-bit 128x128 grid of trees. The pointer starts at [0,0]. The code is situated at [-1, 0], and the program ends when this is overwritten with any value. Outside of [0,0] to [127,127] is a duplicate of [127,127] branches (including edit modifications). By default, all branches are at 16. Attempting to underflow will keep it at 0 and overflowing at 255, respectively. Since there is no way to add/subtract without pulling from other branches, you only have total of 262144 branches to use.
== Instruction Set ==
move [x] [y] times moves the pointer up (0-63), down (64-127), left (128-191), or right (192-255). X and Y can either be a number or just "pointer". 
add [x] branches to pointer adds [x] branches to the pointer, taking it from the tree. x is a number only. 
place [x] branches from pointer is the opposite of the above instruction, placing branches down instead of taking them. 
take a picture of the tree at the pointer outputs the ASCII value of the tree at the pointer.
take an input takes an input, and puts it where the pointer is. It will use branches from [127,127] and go up to [127,0]. If it still does not have enough branches, it will look through [126,127] to [126,0], and so on until it finds enough. 
define a function as "this is some random text [x] [y] [z]" will define a function. executing the function would just be like executing any other instruction, like this is some random text 120 120 pointer
== Examples ==
=== Hello, World ===
todo lol
Category:Cell-based Category:2021 Category:Two-dimensional languages
ForeverGolf

This language extension makes every operation loop, and was created by User:Poolala. The reason this was made was to create some interesting code golf programs.
==How it works==
To show how it works, I'm gonna take the language Brainfuck, and put the ForeverGolf extension on it.
Now, every operation requires an extra parameter: how many cycles until it executes again. 
If an operation hasn't executed yet, it waits its number of cycles before it executes.
If two operations are set to run at the same time, the operation that's closer to the beginning of the file goes first.
For example, +:1 -:3 would do this in normal brainfuck code: nop + + + - + + + - + + + - in an infinite loop. 
Note: only add the extension to true operations, not labels, function declarations, etc.
Category:2013
Category:Ideas
Forex

“Forex” is a model of computation devised by Mason Green in 2022. It can be proven Turing-complete as it is a generalization of Bag and Fractran.
Forex, as the name indicates, uses a trader who exchanges currencies as an analogy for computation. The trader carries a wallet which can hold varying, non-negative amounts of each currency. The minimum amount of each currency is zero, while there may or may not be upper limits on how much the wallet can hold. If there are upper limits, they can apply to a single currency or jointly to multiple currencies. For instance if there are black and white currencies, limits could be specified as (black <= 30), (black + 2*white <= 45), etc.
There is also an ordered list of possible exchanges the trader can make. On each step, he will always attempt to make the first trade in the list. If he either does not have enough currency to cover the trade, or would end up with an over-stuffed wallet afterwards, then he will attempt the next trade on the list instead, and so on. Unlike real trades, these can occasionally involve simply giving away or receiving currencies for nothing in return.
One convention is to name the currencies as colors, which makes it possible to imagine bills or coins of that color being physically traded.
==An example==
One list of possible trades is:
-(1 red) -> (1 blue)
-(2 blue + 1 yellow) -> (2 red + 1 green)
-(2 blue) -> (1 grey)
-(1 blue + 1 orange) -> (1 red + 1 grey)
-(1 blue + 1 grey) -> (2 red + 2 yellow)
-(1 grey + 1 green) -> (1 orange + 1 yellow)
-(1 grey) -> (2 blue)
-(1 green) -> (1 blue)
-(1 yellow) -> (nothing)
-(nothing) -> (1 grey + 1 blue)
Assuming the wallet has unlimited capacity for each currency, then this is equivalent to Devin Kilminster‘s Fractran program for generating prime numbers, as described in the Fractran article. The currencies correspond to prime factors: yellow (2), red (3), orange (5), blue (7), green (11) and grey (13).
We start with (1 orange + 1 yellow), which corresponds to n=10. From then on, whenever the wallet holds the same amount of orange and yellow currency (all other currencies being zero), the number of units of each type will be prime, and the program visits all primes in increasing order. This corresponds to the original program visiting only those powers of 10 in which the exponent is prime.
==Additional features==
Compared to Bag and Fractran, Forex has two additional features that give it more potential. First, it allows an upper as well as a lower limit on the amount of some currencies in the wallet. This, in Fractran terms, would be analogous to placing upper limits on the exponents of certain prime factors of the number n.
Second, the quantity of currencies in each trade doesn’t have to be an integer, and in fact can be any real number, including irrational numbers. This makes it possible to simulate aperiodic sequences like the Fibonacci word and Sturmian words extremely easily, as well as opening the door to chaotic behavior (in which having 0.000001 more or less of a particular currency could have major effects on what the trader does in the future).
Category: Turing complete Category:Computational models Category:2022
Forget

==Forget==
Forget is a stack-based language where pointers are poisonous and the interpreter doesn't do a good job of remembering non-constant values
==Syntax==
Instructions are separated by semicolons.
push (number) 	writes the given decimal integer to memory and pushes a pointer to the stack
pop 	pops a pointer from the stack so it can be used
in 	reads a single character from standard input, stores it in memory, and pushes the corresponding pointer to the stack
read (address) 	loads the value stored at the given address so it can be used.
write (address) (number)	writes the given number to the memory at the given address
cleanse (pointer) 	makes the given pointer non-poisonous. If no pointer is provided, the one on the top of the stack is cleansed
const (address) (number)	same as write, but is immutable and can only be used before any other instruction is processed
out 	prints the value on top of the stack as a character
dump 	clears the stack, printing each value as a character
while (address) 	executes the code in between this instruction and the corresponding end instruction while the value at the given address is greater than 0
hasin 	a special variant of while that loops while data is available from standard input
end 	marks the end of a while block
add (value1) (value2) 	adds the arguments (pointers or numbers) and pushes the result to the stack. If an argument is missing, the value on the top of the stack is used
sub (value1) (value2) 	same as add, but subtracts instead
==Errors==
Any attempt to deference a poisoned pointer will result in a segmentation fault
Reading an unallocated address has a chance of either segfaulting or returning garbage data
==Examples==
Here is a computer-generated Hello, World! program written in Forget:
 const 0x0 10;
 const 0x1 33;
 const 0x2 100;
 const 0x3 108;
 const 0x4 114;
 const 0x5 111;
 const 0x6 87;
 const 0x7 32;
 const 0x8 44;
 const 0x9 111;
 const 0xa 108;
 const 0xb 108;
 const 0xc 101;
 const 0xd 72;
 cleanse 0xd;pop;out;
 cleanse 0xc;pop;out;
 cleanse 0xb;pop;out;
 cleanse 0xa;pop;out;
 cleanse 0x9;pop;out;
 cleanse 0x8;pop;out;
 cleanse 0x7;pop;out;
 cleanse 0x6;pop;out;
 cleanse 0x5;pop;out;
 cleanse 0x4;pop;out;
 cleanse 0x3;pop;out;
 cleanse 0x2;pop;out;
 cleanse 0x1;pop;out;
 cleanse 0x0;pop;out;
This is a cat program written in Forget. Terminates after a newline:
 in;
 cleanse;
 out;
 hasin;
 in;
 cleanse;
 out;
 end;
==Resources==
Forget interpreter (written in Java)
Category:Languages Category:Stack-based Category:Implemented
Forget Me Not

Forget Me Not is a programming language by User:PixelatedStarfish which is influenced by INTERCAL. The instruction pointer will forget what it was trying to do and start over (or go to the last label). When it forgets, it will replace the instruction it was executing with a randomly generated instruction (in RAM, this is not a self-modifying language). The only way to prevent forgetfulness is to include regular comments that remind the instruction pointer of what to do. For optimal usability, comments should appear in at least one of every 5 lines and no more than one of every 3 lines. If there are not enough comments, the pointer forgets. If there are too many, the pointer feels patronized and refuses to execute the code. 
The language is stack based and has a syntax similar to an assembly language. Each instruction gets a line to itself, with arguments separated by a space.
A value on the stack can be in the range of 0 to 255 inclusive. 
==Instructions==
Command 	Args 	Desc.
PUSH 	VALUE 	Push value on to stack.
ADD 	VALUE 	Add VALUE to value at top of stack.
SUB 	VALUE 	Subtract VALUE from value at top of stack.
SWAP 	POSITION 	Swap the value at the top with the value at the specified position in the stack.
LBL 	IDENTIFIER	A Label.
GOTO 	IDENTIFIER	Go to identified label.
CBZ 	IDENTIFIER	Go to label if value on stack is zero.
CBNZ 	IDENTIFIER	Go to label if value on stack is not zero.
CBE 	IDENTIFIER	Go to label if stack is empty.
CBNE 	IDENTIFIER	Go to label if stack is not empty.
POP 	None 	Pop value off of stack.
CHAR 	None 	Print top value as ASCII char.
VAL 	None 	Print top value as value.
DUP 	None 	Duplicate value at top of stack and push.
SHFL 	None 	Shuffle stack.
INP 	None 	Take input as an integer value.
GOBL / RET / GOBLINS / RETURN	None 	Goblins. Go to last GOTO and execute the next line.
R 	None 	Reverse the stack.
Q 	None 	This is the quine instruction, which prints itself.
NOTE / CMT 	None 	A note or comment.
START 	None 	Indicates where the program starts. This is optional, but it can be useful for programs that do not start on the first line.
HLT / END 	None 	End program.
Category:Languages Category:Unimplemented Category:Stack-based Category:2021
ForgottenV

ForgottenV is EsoLang made in 2021 by User:Supyovalk.
==Summary==
ForgottenV works like c,but with a twist:upon variable declaration,every N instructions afterword (N is a number randomly selected from 1 to 50 per each variable) the variable is reconstructed (Basically activing the class's default constructor on it). However , for each class exists a root variable (can be accessed by "Class-name".RT) that isnt effected.
==Example==
This program is likely to get stuck in a infinte loop:
int main(){
 int i = 10;
 while(i<30):
 printf(i,"%d");
 i++
 } 
return 0;
}
But this wont:
int main(){
 int.RT = 10;
 while(int.RT<30):
 printf(int.RT,"%d");
 int.RT++
 }
return int.RT - int.RT;
}
Category:Languages Category:Unimplemented Category:High-level Category:2021 Category:Nondeterministic
Fork

Fork is brainfork, but with only the Y command. The Y command spawns a thread that executes the program itself. It also doesn't have a tape.
==Examples==
===Fork bomb===
 YY
The program spawns 2 threads and each thread spawns 2 threads and so on until your computer explodes.
===Infinite loop (sort of)===
 Y
==ProcessFork==
ProcessFork is a variation of Fork where the Y command spawns a process instead of a thread.
===Examples===
====Fork bomb====
 YY
Batch equivalent:
 %0|%0
It causes more damage to your computer than the Fork fork bomb program.
Category:Languages
Category:Joke languages
Category:Unusable for programming
Category:Unknown computational class
Forks & Forks

Forks & Forks is a simple esoteric programming language influenced by Pistons & Pistons invented by User:A; this was created in order to make Pistons & Pistons easier to implement.
==Symbols==
Programs start on the first character of the program. These determine whether a father process will be forked. Take this as an example:
.V V 
 
 > 
 6,
This program will eventually halt as it prints a few spaces. In the first character of the program it created a father process that is moving right (. is > typed without using the shift key, so it represents a father process); these processes will output every character on its way except for its built-in commands. If processes try to go to the same cell at the same time, both of them will be terminated. (That is why there is a 6, on the bottom of the program, and it is the only way to terminate processes.) If a process is going out of the bounds of the program, it will not be terminated.
On the next step, a fork of this process will be created(going down). Then, a fork for this process will be forked again to move right. (This father process will be terminated by the left-moving ,.)
Then, there are three processes left: >, V, and 6. 6 is used to terminate the main process. The > will collide with V, terminating them both.
If a process is not terminated when it goes over the bounds of a program, it will start to output 0x00 forever.
== List of commands ==
* >, V, <, ^: these are fork-process commands; this creates a fork of the father if it was in the way of the father. An easy way to remember them is that they all are pressed using the shift key. (At least on the QWERTY keyboard)
* ., v, ,, 6: these are main-process commands; these create a root process for fork commands to fork. An easy way to remember them is that they all are pressed not using the shift key. After new processes are created, they are converted into the corresponding keys on the QWERTY keyboard without using shifts.
==Examples==
This example outputs x to the console forever:
>vx 
6, 
 .v
 ^,
=== Infinite loop ===
v
=== Hello, world! program ===
.Hello World! 
 
 
 
 
 
 
 
 
 
 
 
 6
==Implementations==
I don’t believe this language can be implemented, however, please prove me wrong if it can. 
==Computational class==
Like Pistons & Pistons, its computational class is also unknown. However, I will be glad if this can perform as many computations as Pistons & Pistons could.
Category:Languages
Category:2019
Category:Unimplemented
Category:Low-level
Category:Output only