nyuuzyou/wikis huggingface dataset:
If the question specifies that the number of the words should be less than 3, and the number of words in your answer is larger than 3, your answer is automatically wrong.

If the question specifies that the number of the words should be less than 3, and the number of words in your answer is larger than 3, your answer is automatically wrong. is an esoteric programming language invented by User:A inspired by this sentence: If the question specifies that the number of the words should be less than 3, and the number of words in your answer is larger than 3, your answer is automatically wrong, where the question specifies that the number of the words should be less than 3, and the number of words in your answer is larger than 3, your answer is automatically wrong. It was created when someone mailed "If the question specifies that the number of the words should be less than 3, and the number of words in your answer is larger than 3, your answer is automatically wrong".
== Syntax ==
The question is a string of symbols that will be entered from the input. The symbols that will be entered from the input will be from the ASCII table.
You are required to append your answer into the input; it will also be a string of ASCII symbols. Otherwise, the grader will not be able to check your answer and your answer will automatically be an "×"; in other words, it will automatically be wrong.
Your answer will be substituted as "valid" or "not valid"; that will signify whether you got the answer correct or not.
# If the question specifies that the number of the words should be less than 3, and the number of words in your answer is larger than 3, your answer is automatically wrong.
Q.len < 3 & U.len > 3 : U.ans = automatically "wrong"
# If the question specifies that the number of the words should be less than 3, and the number of words in your answer is larger than 3, your answer is automatically wrong.
Q.l<3&U.l>3:U.a="wrong"
This language is very trivial. Here is a list of commands:
?.len (or simply ?.l) Find the length of the lists. (There are only two lists: the question and your answer.)
automatically Syntactic sugar, in order to help people to read this
"x" The string constant x.
< Less than.
= Assignment.
> Greater than.
& And operator.
: Signifies an "if" condition using the values in the preceding half of the line.
number An integer constant.
?.ans (or simple ?.a) The answer. It is the list.
In order to help people to read this language without special knowledge, here is a verbose version of the program above:
If the question specifies that the number of the words should be less than 3, and the number of words in your answer is larger than 3, your answer is automatically wrong.
Category:Languages
Category:Joke languages
Category:2019
Category:Unimplemented
Category:Total
Category:Unusable for programming
Category:Finite state automata
Iflang

Iflang is a language created in 2020 by User:Hanzlu. The memory consists of two cells, both containing 1 bit each. The language is supposed to be useless.
Command	Explanation
( 	Loop
) 	If cell is 1, start loop over again
1 	If cell is 1, move pointer to the other cell. If within a loop, flip the bit in the cell.
0 	If cell is 0, output the bit in the cell. If within a loop, flip the bit in the cell.
Iflang code for printing out a '0'
 (11001)
Interpreter:
 file = open("ifcode", "r")
 code = file.read()
 
 loop = False
 loops = 0
 
 cell = [0, 0]
 ptr = 0
 
 i = 0
 while i < len(code):
 
 if code[i] == "(":
 loop = True
 loops += 1
 
 elif code[i] == ")":
 if cell[ptr] == 1:
 x = 1
 while x != 0:
 i -= 1
 if code[i] == "(":
 x -= 1
 elif code[i] == ")":
 x += 1
 else:
 loop -= 1
 if loop == 0:
 loop = False
 
 elif code[i] == "1":
 if cell[ptr] == 1:
 ptr = 1 if ptr == 0 else 0
 if loop == True:
 cell[ptr] = 1 if cell[ptr] == 0 else 0
 
 elif code[i] == "0":
 if cell[ptr] == 0:
 print(cell[ptr])
 if loop == True:
 cell[ptr] = 1 if cell[ptr] == 0 else 0
 
 i += 1 
 
 file.close()
Category:Languages Category:Implemented Category:Finite state automata Category:Unusable for programming Category:Output only Category:2020
Iframe

Iframe is an esolang based on HTML iframes and the a tag target attribute.
== Syntax ==
Each line of the program encodes a page. The line starts with a sequence of alphanumeric characters that will be used as the name of the page, followed by a colon, then a sequence of elements. Each element can be either an iframe or a link.
* An iframe is specified by its name (which also only consists of alphanumeric characters) and optionally an equal sign followed the page it starts as. For example an initially blank iframe named "a" is simply a, and an iframe named "a" initialized to the page "b" is a=b.
* A link is specified by its target, then an arrow, followed by the page it links to. For example, a link that changes the source of an iframe named "a" to the page "b" is a->b
An undefined page is treated as a blank page.
=== Special targets ===
Just like in HTML, there are special targets that refer to special iframes, namely _self, _parent, and _top. Iframe can also be extended with output using _out, where the only valid pages consist only of digits which are interpreted as a Unicode codepoint in decimal and outputted.
== How it runs ==
At the beginning, it starts at the page named "index".
The "instruction pointer" goes through every element. If it's a link, it clicks that link. If it's an iframe, it goes inside the current page of that iframe. If there are no more elements in the current iframe, the instruction pointer continues in the parent iframe. If the instruction pointer is already on the top iframe, the program halts.
If the current iframe's (or one of its parents') source is changed, the instruction pointer starts from the beginning of whichever iframe was updated.
If an iframe's source is a non-existent line, the iframe is considered blank.
=== How iframes are targeted ===
# If the current iframe's name is the same as the target, set this iframe's source to the destination and stop.
# For each iframe in the current iframe, repeat the first 2 steps.
# Go up one iframe and go back to step 1.
== Examples ==
=== Alternating between C and B ===
 index: A=initA B=initB C=initC
 initA: subA=nextC
 initB: subB
 initC: subC
 nextB: _out->66 subB->index a->
 nextC: _out->67 b->switcheroo subC->index a->
 switcheroo: subA->nextB
This program shows how control flow might work in iframe.
Category:Languages Category:Usability unknown Category:Unknown computational class Category:Unimplemented
Ifthen

Ifthen is an uncomputable esolang invented by User:None1.
==Syntax==
Ifthen's syntax is:
If(<Statement>) Then Do All The Things Below{
 <Thing>;
 ... # More things
}
Note that the statement and the things can be anything! 
You can even do something impossible, like:
If(One plus One Equals To Two) Then Do All The Things Below{
 Clear The Universe;
 Prove that a square is a circle;
 qowoejdbxdjdidjxnxjdidixn;
 Become a Chicken;
}
Ifthen is case sensitive.
==Example Programs==
===Hello World===
If(True) Then Do All The Things Below{
 Print "Hello World!" to the Console;
}
===Quine===
If(True) Then Do All The Things Below{
 Make this Program a Quine;
}
===Truth Machine===
If(True) Then Do All The Things Below{
 Read Integer A;
}
If(A=0) Then Do All The Things Below{
 Print A to the Console;
}
If(A==1) Then Do All The Things Below{
 Print 1 to the Console Infinitely;
}
It can be seen that Ifthen can correctly understand both = and ==
===Easier Truth Machine===
If(True) Then Do All The Things Below{
 Truth Machine;
}
==Non Existent==
This language is non-existent because it can do anything.
==See Also==
* Compute
Category:Uncomputable
Category:Unusable for programming
Category:Languages
Category:Joke languages
Category:2023Category:Pseudonatural
Ifunge

ifunge /ˈaɪfʌndʒ/ (name always lowercase) is an image version of Befunge, created by User:None1
==Syntax==
ifunge programs are grayscale images, the grayscaleof each pixel represents an ASCII character in a Befunge program (e.g., A pure black pixel stands for a null character).
When running, ifunge programs transpile into Befunge.
==Example Program==
===Hello World===
===Cat Program===
===99 bottles of beer===
==Interpreters==
Here is a translator from ifunge to Befunge, in Python:
# ifunge translator to Befunge
# usage: python ifunge.py <image file name>
from PIL import Image
import numpy as np
import sys
img=Image.open(sys.argv[1])
a=np.array(img)
for i in a:
 for j in i:
 if not hasattr(j,'__iter__'):
 j=[j]
 print(chr(max(j)),end=)
 print()
And an encoder from Befunge to ifunge:
from PIL import Image
import numpy as np
import sys
k=sys.stdin.read().split('\n')
l=[]
maxlen=0
for i in k:
 maxlen=max(maxlen,len(i))
for i in k:
 y=[]
 for j in range(0,maxlen):
 try:
 y.append(ord(i[j]))
 except:
 y.append(32)
 l.append(y)
Image.fromarray(np.array(l),mode='L').save(sys.argv[1])
They require pillow and numpy packages.
Category:Languages
Category:Non-textual
Category:Two-dimensional languages
Category:Joke languages
Category:Turing complete
Category:Implemented
Illegal Characters

"{{{{{{{{{@@^^ᵒ is a language which can be used to solve any code golfing problem, but with a slightly (depends on your skill level) worse score than the best golfer. 
==Examples==
Hello World
 "{{{{{{{{{@@^^ᵒ
Category:Languages
Category:Uncomputable
Category:Turing complete
Category:Golfing language
Category:Joke languages
Category:2021
Ilo nanpa sitelen

ilo nanpa sitelen (computer art) is a language based around toki pona.
== Basic overview ==
ilo nanpa sitelen uses a stack and a queue. The stack is for data storage, and the queue used either as secondary storage or to store instructions (see below).
tenpo kama la mi wile pali e ni
Category:Languages Category:Works-in-Progress Category:Unimplemented Category:2025
ImTooLazyToMakeAnActuallyGoodEsolang

ImTooLazyToMakeAnActuallyGoodEsolang or Laziness is an esolang but the creator, User:Evylah got lazy to make a half-decent language. It is not Turing-complete and is output only. One possible use case could be to send messages to other people (even though they'd be very long).
== Overview ==
This language is pretty useless unless you want to output text. It is made up of one queue, which can hold values either 1 or 0. The current bit (which gets flipped with -) is also stored. The current bit is initialized to 0, and the queue is initially empty.
== Commands ==
Opcode	Description
- 	Flips the current bit
. 	Adds the current bit to the output queue
, 	Read the entire queue as a binary number and output it as a character. (Pop every value and add it to a temporary string, then convert that string from binary to Unicode and print it.)
Every other character is ignored and can be used as a comment.
== Examples ==
=== XKCD Random Number ===
The Unicode character for "4" in binary is 1100002.
 -..-....,
Pushes 1, 1, 0, 0, 0 and 0, in that order. Then it outputs 1100002 or "4"
=== Hello! ===
Not Hello, World! because I'm too lazy to write a program or make a generator.
 -.-..-.-..., H
 -..-..-.-.-., e
 ..-.-..-.., l
 -..-.-..-.., l
 -..-.-...., o
 .-....-., !
== Computational class ==
Laziness is obviously not Turing-complete. Since I'm not smart, some of these other classes could be inaccurate.
* Laziness is a Push-down automaton, because it uses a single stack (although not very useful)
* Laziness always halts.
== Interpreters ==
=== Python ===
def laziness(code: str) -> None:
 bit = 0
 queue = "" # xd
 for char in code:
 if char == "-": bit = ~bit
 elif char == ".": queue += str(abs(bit))
 elif char == ",": print(chr(int(queue, 2)), end=""); queue = ""
laziness(input())
Category:Languages Category:2024 Category:Output only Category:Total Category:Unusable for programming Category:Push-down automata Category:Queue-based Category:Joke languages Category:Implemented
Im not mad at yayimhere anymore

im not mad at yayimhere anymore is both an esolang and a public announcement by user:tommyaweosme
== commands ==
 yay "" - print string to screen
 im n = o - declares a variable n to be o
 n = o - sets n to o
 n + o - sets n to n + o
 n / o - sets n to n / o
 n x o - sets n to n x o
 n % o - sets n to n % o
 n ! - sets n to its negative (9 -> -9)
 n r - sets n to its reciprocal (9 -> 1/9)
 here n < m[]: does whats in brackets if n < m
 imhere - prints user input
 yayim - waits 1 second
 yayhere n < m[] - does whats in brackets while n < m
== cat ==
 yay imhere
== hello world ==
 yay "hello world!"
== fibonacci ==
 im first = 1
 im second = 1
 im third = 0
 im counting = 1
 yayhere counting < 200[
 third = first
 third + second
 first = second
 second = third
 counting + 1
 yay third]
== truth machine ==
 im input = imhere
 yay input
 here input < 2[
 here 0 < input[
 yayhere 1 < 50[
 yay input]]]
Image

Image is a programming language by User:Rdococ and ancient ancestor to Text. Image is a relatively unknown language, but most graphics, such as photographs, bitmaps and pixel art are actually written in Image.
== Overview ==
Image programs are represented by graphics, often in .BMP or .PNG file formats. All programs output their own source code, making every program a quine.
Despite the relative youth of the language's specification, there is a lot of hardware and software support for Image. The traditional interpreter is a photo viewer, but operating systems and web browsers also include facilities for executing Image programs.
The first known Image interpreter was a cave in Indonesia, which was used to write and execute an Image program 45000 years ago to generate images of wild pigs.
== Computational Class ==
Image has the ability to perform computations using human visual processing. Used this way, it is a programming language for the visual cortex. Memory depends on multistable perception in different parts of the image, and is bounded by the size of the image a la bounded storage machines.
There are some dialects of Image which are Turing-complete, such as SVG. 
Category:Joke languages
Category:2017
Category:Graphical Output
Category:Languages
Category:Non-textual
Category:Implemented
ImageFuck

ImageFuck is an esoteric programming language created by user:Insanity.
In its essence, ImageFuck is a version of Brainfuck created by altering pixels of an image. It supports the same operators as Brainfuck and will actually compile to Brainfuck code before being run through a Brainfuck interpreter. 
As Brainfuck is a Turing Complete language, so is this version which is really a layer on top of Brainfuck. And just like Brainfuck, any colour appearing in the image that is not defined as an operator is considered a comment. You can make an entire picture and hide some ImageFuck code in it by colouring just specific pixels.
Pixels are read from left to right, row after row. 
The source code for ImageFuck is in this Github Repository and includes examples of how to use the language. It is written in Python and includes a tool to go from existing Brainfuck code to an ImageFuck image. 
For example, the first 7 numbers of the Fibonacci sequence can be created by running this image.
The various operators of brainfuck are made by these pixel colours
Colour (RGB)	BrainFuck code
(255,0,0) 	>
(0,255,0) 	.
(0,0,255) 	<
(255,255,0) 	+
(0,255,255) 	-
(255,0,188) 	[
(255,128,0) 	]
(102,0,204) 	,
As these values need to be set 'exactly', the files can not deal with compression. If you use .jpeg for example the resulting code will be _wrong_. 
PNG files are better suited for this as they are lossless.
ImagePath

ImagePath is an esoteric programming language created by Dominicentek for Truttle1's Visuals Esojam. It has a pointer that executes pixels in an image as instructions. Path is randomly chosen.
== Path Choosing ==
When the pointer goes to another pixel, it chooses its direction and goes in that direction. It cannot go back where it came from. Black pixels act like walls, where the pointer cannot go. If there's no way to another pixel, it quits the program.
== Instructions ==
Color 	Description
#00FF00	Acts as a starting point. If there are multiple, it chooses it's starting point randomly. If there's none, the program instantly quits.
#FF0000	Ending point. If the pointer reaches it, it quits the program.
#000000	A wall. The pointer cannot go there.
#0000XX	Pushes a value of blue onto the stack
#FFFF00	Pops a value off the stack
#00F000	Reverses the stack
#000F00	Swaps top 2 values on the stack
#F0FF00	Outputs the top value of the stack as a number and pops it
#0FFF00	Outputs the top value of the stack as an ASCII character and pops it
#00FFFF	Asks user for input
#7F7F7F	Gateway. Once passed, it turns into a wall
#FF00FF	If statement. If the top value is 0, it goes forward, otherwise it goes like normal. If blocked, the program quits. Value then gets popped.
#F0F000	Addition. Pops 2 values x and y, and pushes y + x
#F00F00	Subtraction. Pops 2 values x and y, and pushes y - x
#F000F0	Multiplication. Pops 2 values x and y, and pushes y * x
#F0000F	Division. Pops 2 values x and y, and pushes y / x
#FF7FFF	Pushes the amount of elements in the current stack to the stack.
#F000FF	Oneway. Cannot go on it from top
#0F00FF	Oneway. Cannot go on it from left
#00F0FF	Oneway. Cannot go on it from bottom
#000FFF	Oneway. Cannot go on it from right
== Examples ==
File:ImagePath_-_Hello_World.png|Hello World
File:ImagePath_-_Truth_Machine.png|Truth Machine
File:ImagePath_-_Cat_Program.png|Cat Program
== Interpreter ==
* None
Category:Unimplemented
Category:Two-dimensional_languages
Category:Languages
Category:Stack-based
Imagerlang

Imagerlang is a programming language that uses images to make data
= V1 =
== Commands ==
 + increment the X var
 * increment the Y var
 - decrement the X var
 / decrement the Y var
 # place a cell at X var Y var where the value is X var
 $ place a cell at X var Y var where the value is Y var
 ~ place a cell at X var Y var where the value is a input which is X var or Y var, like the question is "X or Y"
 ! check the cell at X var Y var and if it is the value of its X position, set the its value to its Y position
 & if the cell at X var Y var is its X position, Set Y var to its X position, and set X var to its Y position
 % if the cell at X var Y var is its Y position, Set X var to its Y position, and set Y var to its X position
 @ if the X var and Y var is 0, continue, else return X
== Examples ==
 +~-*~/+&&-@ a thing that detects if both of them is X X or Y Y, then Y, else X
 +~-*~/+&/@*&-@ a thing that detects if both of them is X X, then Y, else X
= V2 - modular Imagerlang =
== New Commands ==
 ^ increment the Z var
 | increment the W var
 v decrement the Z var
 \ decrement the W var
 ` add Z var W var to input list
 = clear input list
 [ start a function with the letter after it being the name, and the input list is its inputs
 ] end a function, note if the function reaches this when ran, Y is returned
 L run a function where L is the function name, with the inputs based on the input list, if results in X, set the cell at X var Y var before the function was to X, else set it to Y
== Examples ==
 =^`v|`\[N+&/@]=+#N%/@ run not on X which results in Y
Imaginary function

In the context of some putative, bizarre, and quite possibly inconsistent world
of idealized functional programming, an imaginary function is an object that,
while not necessarily a higher-order function, when applied, yields a function.
Take add as an example of a function. The following statement is tautological,
or at best metacircular, but demonstrates how we will use equality and an Erlang-like syntax
for functions in this rest of this explanation explanation.
 add = fun(X, Y) -> add(X, Y)
Now consider two things called apply and thunk. It is probably
best to think of them as operations on functions, rather than functions themselves. But
for simplicity we'll define them like we define functions. They could be defined as:
 apply = fun(F) -> F()
 thunk = fun(F) -> (fun() -> F)
From the following example, we can conclude that there are cases where apply
is the inverse of thunk:
 apply(thunk(add)) = add
And from the following example, we might conclude that there are cases where thunk
is the inverse of apply:
 thunk(apply(thunk(thunk(add)))) = thunk(thunk(add))
So in the putative, bizarre, and quite possibly inconsistent world of idealized
functional programming where the concept of imaginary function lives, we will
not stop to question those observations, we will just go ahead and say
apply and thunk are always inverses of each other.
So, the following equality also holds:
 thunk(apply(add)) = add
In the above example, apply(add) represents an imaginary function.
(Side note: this is not necessarily the same thing as a "regular" appplication of add, say add(2,3). However, if add had arity zero, I think we'd expect the definitions to coincide, although I don't offhand see how they could.)
There are many possible levels of imaginariness, as the following also holds:
 thunk(thunk(thunk(apply(apply(apply(add)))))) = add
This concludes my description of imaginary functions. All that remains is to
make this world of idealized functional programming no longer putative, by finding a
definition for it, whether consistent or not.
Category: Concepts
Imperative

Imperative is a minimalist language invented by User:A designed to fit into the definition of an imperative language.
== Definition ==
1.Imperative programming
Most imperative languages support the following instructions:
（1）Arithmetic commands
（2）Looping commands
（3）Conditional statements
（4）Unconditional branches
== Examples ==
Demonstration of conditional statements, unconditional branches, and arithmetic commands.
a=1-1
go a*3--3
Execution:
1/0
3/0
6/3
So this jumps to either line 3(when 1 equals 1) or line 6(when 1 does not equal 1).
Looping
b=1
do {
 a=1
} while(b==1)
Implementation:
b=1
a=1
go(b-1)*2--1
== A boring attempt on simplification ==
A simple repeat loop covers all 4 features:
repeat 3 {
 // (1) This decrements registers internally in each iteration.
 // (2) This is a loop.
 // (3) If value = 3 quit loop.
 // (4) branch back to beginning of block.
}
So programs can simply be
repeat 3
or simply a number
3
Category:Languages
Category:2019
Category:Unimplemented
Imperial

Imperial is a work-in-progress language in the concepting stage, by User:IFcoltransG. It will be used for hiding programs steganographically in poetry. The compiler (or possibly interpreter - it's too early to get hung up on) will parse the metre (hence the name) of the poem and reinterpret it as instructions. Presumably the language will follow an imperative paradigm, because of the wordplay. It was first thought of in late 2019, in case you wish to gauge inactivity.
== Eternal Resources ==
(Note: these resources may not be eternal, but the language is about poetry, so the typo shall eternally remain.)
* Project Github
Category:Languages Category:2019
Impfish PDA

Impfish PDA is an esolang by User:BoundedBeans which aims to be like Deadfish PDA but procedural rather than declarative.
==Differences==
* Input is taken through an instruction, not every time.
* Input can be any character.
* There is no limit to the number of states, but they must be positive.
==Commands==
 i - increment state
 d - decrement state
 s - square state
 o - output state
 a - push a
 b - push b
 c - push c
 ! - push !
 ^ - pop from the stack
 : - input into current character
 Note: this can be any character, unlike in normal Deadfish PDA where it can only be X, Y, Z, or ?.
 [(state)(top of stack)(current character)]=(name)= - go to label name if match
 "(name)" - define label name
==Examples==
===Truth-machine===
Use numerical output.
 i:[1!1]=True=[1!0]=False="True"o[1!1]=True="False"do
Category:Push-down automata
Category:Languages
Category:Unimplemented
Implicit

Implicit, also called SimpleStack, is a WIP language by MD XF. There are two types of commands:
* Those that behave differently on strings than they do on integers/floats
* Those that behave the same no matter what the top stack value(s) is/are
Commands are called with one integer as the only argument. All commands, except those that don't, can be called implicitly, and have different behavior when done so. For example, when + is called implicitly, it adds the top two stack values together. When + is called with a number, it adds the number to the top stack value.
Category:Languages Category:Stack-based