nyuuzyou/wikis huggingface dataset:
I like frog

:Note that i like frog is typically lowercased except, often, at the start of a sentence.
 
I like frog was invented by User:Apollyon094 in 2020, as a joke on an image seen here.
I like frog is a set of 16 commands (including the newline as a command to end a command) based on the following syntax to have them executed. Line breaks end commands and their parameters.
Each line/command is started with one of 3 categories of commands, being "i ", "like " or "frog "
The following categories and their commands are as below:
i (if called without "like" or "frog", go to cell number X where X was the value underneath the pointer before it moved):
 like: Go forward X cells where X = the parameters. If no parameters, move forward one.
 frog: Go backwards X cells where X = the parameters. If no parameters, move backwards one.
like (if called without i or frog, output all cells written to):
 i: Insert X in binary into cells to the right of the pointer where X = parameters. If no parameters, take input from console.
 frog: Output X where X = parameters. If no parameters, output bit under pointer.
frog (if called without i or like, invert base-16 command under IP and go to instruction number X where X is the value under the data pointer.)
 i: Go forward X instructions if bit = 0 where X = parameters. If no parameters, rotate data bits by 4 left, rotate command bits by 2 left and go forward 1 instruction.
 like: Go back X instructions if bit = 0 where X = parameters. If no parameters, rotate data bits by 4 right, rotate command bits by 2 right and go back 1 instruction.
I like frog is Turing-Complete since it can compile to Boolfuck as well as Nanofuck and execute infinite loops
UPDATE: Parameters are now bitwise. You can choose from "i, like (and) frog" in this order. You can only pick from 2 since the last word (i, like, frog) cannot be used again. Therefore you have 2 choices which, in order, can be equivalent to 1s and 0s. The parameters are also read as bytes (padding 8). I don't think endianness is a problem here.
If you wrote an interpreter, please post it here. I'm bad at programming and can't figure out how to skip back and forward instructions.
==Examples==
===Hello, World!===
This program prints out the words Hello World!:
like frog i frog i like frog i like i like i frog like frog i like frog i frog i frog like i frog like i like i frog like i frog like frog i like i frog like i frog like frog like i like frog i frog like i like i like frog i like i like i like frog i frog i frog like frog i frog like i frog like frog like i frog like frog i like frog i like frog like i frog like i like i frog like i like frog i like i like frog i like i like frog
===Infinite loop===
This program executes an infinite loop:
frog like i
What this does it it goes back an instruction, which there is no instruction before it, so it goes to the last instruction which is it.
Category:Turing tarpits 
Category:Low-level 
Category:Cell-based 
Category:Languages
Category:2020
Category:Turing complete
Category:Joke languages
Category:Self-modifying
Category:Unimplemented
I walk away!

I walk away! Is an esoteric that does a few things, but the main problem being that when you try to do anything, the console's contents, well, walk away. So trying to use a for loop to print "HELLO MORTAL" 75 times would make the message span an entire line.
Or, in other words, your output walks away. You also must add one more space than the previous line at the beginning for it to function. So you own program also looks like it wants to walk away. However the text does not wrap around. So eventually you cannot see any output.
==Commands==
Seems familiar?
 Commands
Command 	Function
Print["string" 	Prints the string
Printn["string" 	Prints a string without newlines
Newline 	Prints a newline
Printv[var 	Print var's value
Printvn[var 	Print var's value without newlines
Define[name,initial value 	Define a variable called name
Input[prompt,name 	Asks for input and store into variable called name
Arith[operation,{operands},into 	Does operation to values in {operands} and store into the variable named into, if the var used already exists, change value
While{value, value, condition}[ 	While loop, does while value is condition to value (i.e. While{1,1,==} checks for 1 == 1)
For{tempname, start, stop, step}[	For loop, var used to loop is temp name, go up by step (if step not given, step = 1)
If{value, value, condition}[ 	If statement, does if value is condition to value (i.e. While{2,2,==} checks for 2 == 2)
]Elseif{value, value, condition}[	Elseif if initial condition not met, same stuff
] 	Closes off all commands
Yea, its pretty obvious it comes from BITWISEBASE64BITWISEBASE64BITWISEBASE64BITWISE.
==Examples==
===Hello World===
Still longer than the one in HQ9+ or its siblings.
 Print["Hello World!"
 ]
===Cat===
 Input[?:, in
 ]
 Print[in
 ]
===Truth Machine===
 Input[?:, in
 ]
 If{1,in,==}[
 While{1,1,==}[
 Printn["1"
 ]
 ]
 Print["0"
 ]
Yea, it looks like a staircase but........
===FizzBuzz===
 Define[count,1
 ]
 While{1,1,==}[
 Arith[%, {count, 3}, M3
 ]
 Arith[%, {count, 5}, M5
 ]
 If{1,1,==}[
 If{M5,0,==}[
 Print["FizzBuzz"
 ]
 ]Elseif{M3,0,==}[
 Print["Fizz"
 ]
 ]
 ]Elseif{M5,0,==}[
 Print["Buzz
 ]
 ]Elseif{1,1,==}[
 Printv[count
 ]
 ]
 ]
 Arith[+,{1,count},count
 ]
Category:Languages Category:2022
Iag

iag is an esoteric programming language with only three commands. It was invented by Panu Kalliokoski.
==Memory==
iag supplies an unbounded number of memory cells initialized to zero. Each cell holds a 32-bit signed integer. There is also an accumulator register, which holds a 32-bit signed integer as well. Looping is performed with the | command and an accompanying stack.
==Commands==
Command 	Description 	Description
< 	Move memory pointer to the left. 	Move memory pointer to the left.
= 	Subtract contents of this memory cell from accumulator, storing the result in both this memory cell and the accumulator, then move memory pointer to the right.	Subtract contents of this memory cell from accumulator, storing the result in both this memory cell and the accumulator, then move memory pointer to the right.
| 	If accumulator is 	If accumulator is
| 	5 	quit.
| 	4 	call time() and save the result in active memory cell.
| 	3 	read a character from stdin to active memory cell (EOF = 0).
| 	2 	print a character to stdout from active memory cell.
| 	1 	do nothing.
| 	0 	set accumulator to 1, add the location of this instruction to the stack, then, only if active memory cell = 0, jump to the command after the next |.
| 	-n 	return to the | instruction you were at n jumps ago, remove n items from the stack, and set the accumulator to 0.
Panu's interpreter also offers the following, presumably not part of the language proper:	Panu's interpreter also offers the following, presumably not part of the language proper: 	Panu's interpreter also offers the following, presumably not part of the language proper:
d 	Dump memory cells for debugging. 	Dump memory cells for debugging.
s 	Dump stack. 	Dump stack.
x 	End the program. 	End the program.
==Examples==
 || === =<=< <<<=== =<=< <=
 ==== |<|<|<|<|<|<|<|
 ds
Reads eight characters of input, storing them in reverse order in the first eight memory cells.
 = || ==<<==== =<=< <= =<=< <<<<<=<==== |
 <= <<= <<== <<= <<== <<= |
Prints all characters 0 to 256 (starting with 1) endlessly.
==External resources==
* iag interpreter in C
* Some small programs in iag
* 
* iag in the Esoteric File Archive
Category:Turing tarpits
Category:Low-level
Category:Implemented
Category:Languages
Category:Unknown year
Ian Osgood

Ian Osgood is a Forth language and esoteric programming language enthusiast from Oregon.
He has invented the language Befalse, and has written JavaScript interpreters/debuggers for SNUSP, FALSE, Biota, Befunge and Brainfuck, as well as programs in SNUSP, Befunge, FALSE, and a personal variant of FALSE called DUP.
==See also==
*User:IanO is Ian Osgood's user page on this wiki.
==External resources==
*Ian Osgood on the C2 wiki.
*JavaScript interpreters for esoteric languages
Category:People
Icarus

Icarus is an attempt at a completely typeless programming language.
== Description ==
=== Variables ===
Each variable does not really have a type. Instead, they have multiple interpretations.
For example, if you set a to 3, it could be interpreted as the number three, a string consisting entirely of the the character 3 (ASCII code 51), or perhaps a regular expression that checks for instances of the character 3, if I decide to implement regular expressions.
Variables can be truthy or falsy. If one of a variable's interpretations is truthy, all of them are. Otherwise, they are all falsy.
Anyway, setting or declaring a variable is easy; just do the following:
a = 3
=== Falsy literals ===
* 0, "0", etc.
* ""
=== Operations ===
 Operations
Operation	Description 	Example 	Evaluation of example
. 	String Concatenation 	"a"."b" 	"ab"
+ 	Numeric Addition 	1+2 	3
- 	Numeric Subtraction 	1-2 	-1
* 	Numeric Multiplication 	1*2 	2
/ 	Numeric Division 	1/2 	0.5
** 	Numeric Exponentiation 	1**2 	1
[] 	Subscript (gets character in a string)	"Hello"[0]	"H"
=== Control Flow ===
Control flow is somewhat C-like.
 if(condition1){
 //Code here only executes if condition1 is truthy
 }else if(condition2){
 //Code here only executes if condition1 is falsy, but condition2 is truthy
 }else{
 //Code here only executes if both condition 1 and condition2 are falsy
 }
 while(condition){
 //Code here repeats until condition is falsy
 }
 try{
 //Code here will try to execute
 }catch{
 //If the code in the try block throws an error, the code here will execute
 }
=== Functions ===
Functions are declared with the function statement, like so:
 function functionName(parameter1, parameter2, ...){
 //Function code
 }
Functions are not first-class variables.
There are also built-in functions, such as `print` and `input`.
== Examples ==
=== Tests if a value is a number ===
 a = input()
 try{
 b = a + 1
 print("You entered a number")
 }catch{
 print("You did not enter a number")
 }
Category:Languages
Category:Unusable for programming
Category:2021
Category:Unimplemented
Ice box

Ice box is a 2D esolang (like Befunge) created by User:AnotherUser05, where instead of a cursor, there are ice boxes going around the code.
Command	Description
> 	Redirects the ice box to go right.
< 	Redirects the ice box to go left.
v 	Redirects the ice box to go down.
^ 	Redirects the ice box to go up.
{ 	Select the previous stored value.
} 	Select the next stored value.
[ 	If the current stored value is equal to the previous one, then jump over to the next ], else continue.
] 	Paired with [.
( 	Jump to the next ) no matter what.
) 	Paired with (.
" 	Declares a string, assuming that it's enclosed.
~ 	Stores the most recent declared string as a value.
+ 	Add one to the current stored value, assuming it's a number.
- 	Removes one from the current stored value, assuming it's a number.
/ 	Swap the current stored value with the next one.
\ 	Swap the current stored value with the previous one.
? 	Generates a random number between 0 and the current stored value, then stores the random number.
# 	Wall.
@ 	Spawns an ice box when the program starts. Every program must have at least one of these.
% 	Creates an empty ice box at every @.
$ 	Creates an ice box where the stored values carries over at every @.
; 	Get an input and then store the value.
: 	Output the current stored value.
_ 	Combines the current stored value with the previous one.
x 	Deletes the ice box.
==Examples==
===Hello World Program===
 @"Hello, World!"~:x
===Number Guessing Game===
 @"100"~?>"guess number..."~:;}v
 >[v]"you guessed it!"~}:x
 ^ :}~"that wasn't it!"<
===Cat Program===
 @;:
===Not Finite Loops===
NF Loop #1
 >)@(<
NF Loop #2
 @%x
===How useful are the walls? I have no idea.===
 @ v
 
 @ #
 
 x
===Truth Machine===
 @;"0"~}[v]:x
 >:<
===Fixed Repeating Output===
 @"0"~;"1"~}v
 >-}:{v
 x:{]^ [<
==Also see==
* Laser Pointer - Another version of Ice box.
Category:Languages Category:Two-dimensional languages Category:Thematic Category:Concurrent programming
Idea

Idea is an esoteric programming language that provides only 4 symbols, making it both very hard to read and write in.
==Instructions==
—=Start/end selection
→=move right
←=move left
Press → and at end of line: evaluate selected text as Idea expression, supports recursion. It will not evaluate a null text.
Press ← and at beginning of line: escape the next character into the file.
All characters that are not these three instructions are preserved in the next evaluation. They do nothing.
==Just one recursion==
a←—→—→
==Two recursions(and so on)==
To create more recursions, put this into the editing area and evaluate it.
←→←←—←←→←←—←←←←a←—→→→→→→—→
Category:Languages
Category:2019
Category:Unimplemented
Ideadfish

Ideadfish is an image version of Deadfish, with char output and operates on a 8 bit accumulator, created by User:None1, overflow and underflow wraps around.
==Commands==
All ideadfish programs are RGB (or RGBA, but the alpha channel will be ignored in that case), images, its height must be 1, every pixel is a command (pixels that are not in the tables are NOPs.
Here are the commands in ideadfish
 Commands in ideadfish
Ideadfish (color)	Deadfish	RGB (HTML) 	Note
 	i 	#7F0000	-
 	d 	#007F7F	-
 	s 	#00007F	-
 	o 	#7F7F7F	-
 	- 	#007F00	Switches output mode of the command from char mode to decimal mode, and from decimal mode to char mode, it is char mode initially.
==Example Programs==
===Hello World===
Real program:
10 times larger program:
==Interpreters==
===Python===
Here is a Python interpreter using the Python Imaging Library and NumPy.
from PIL import Image
import numpy as np
import sys
if len(sys.argv)!=2:
 print('must pass one file as command line argument')
 sys.exit(1)
fn=sys.argv[1]
im=Image.open(fn)
if im.size[1]!=1:
 print('height must be 1')
 sys.exit(2)
if im.mode not in ['RGB','RGBA']:
 print('mode must be RGB or RGBA')
 sys.exit(3)
im=im.convert('RGB')
a=np.array(im)
x=0
mode=True
I=np.array([127,0,0],dtype=np.uint8)
d=np.array([0,127,127],dtype=np.uint8)
s=np.array([0,0,127],dtype=np.uint8)
o=np.array([127,127,127],dtype=np.uint8)
c=np.array([0,127,0],dtype=np.uint8)
for i in a[0]:
 if (i==I).all():
 x=(x+1)%256
 if (i==d).all():
 x=(x-1)%256
 if (i==s).all():
 x=(x*x)%256
 if (i==o).all():
 print(chr(x) if mode else x,end=( if mode else '\n'))
 if (i==c).all():
 mode=(not mode)
Category:Non-textual
Category:Output only
Category:Total
Category:Unusable for programming
Category:Implemented
Idego

Idego(Increment decrement goto) is OISC by User:ChuckEsoteric08.
==Commands==
The code of program is this:
 a b c d
Which means:
Increment cell b by a if positive, else decrement. Goto c if cell is d. If there isn't d in line:
 a b c
Then goto c if not 0.
Cell will not increment/decrement if a is:
Value	Meaning
IN 	input character and set cell to input
OUT 	output cell as ASCII character
If there is only
 a b
Then not goto any command.
==Examples==
===Hello, World!===
 72 1
 OUT 1
 29 1
 OUT 1
 7 1
 OUT 1
 OUT 1
 3 1
 OUT 1
 -111 1
 44 1
 OUT 1
 -12 1
 OUT 1
 55 1
 OUT 1
 24 1
 OUT 1
 3 1
 OUT 1
 -6 1
 OUT 1
 -8 1
 OUT 1
 -100 1
 33 1
 OUT 1
===Cat program===
An infinitely repeating cat program, which terminates for an input of zero, constitutes the following:
 IN 1
 OUT 1 1
===Truth-machine===
The following program implements a truth-machine:
 IN 1
 0 1 5 48
 OUT 1
 0 1 3 49
 OUT 1
==Computational class==
It is Turing-complete, because it is easy to convert every BF program to it
==Interpreter==
* Common Lisp implementation of the Idego programming language.
Category:Languages Category:OISC Category:Turing complete Category:Cell-based Category:Implemented
Idiot

Idiot is an esolang created by User:None1, it is very stupid, but it can still write a cat program and a Truth Machine.
==Syntax==
It uses an accumulator.
 <character> <commands>
If character is empty, then the command is executed no matter what, otherwise it is executed if and only if the accumulator equals to the ASCII value of the character.
==Command==
There are 3 commands, i, o and t.
i reads a character and stores its ASCII value into the accumulator.
o outputs the accumulator as a character.
t terminates the program, the program is executed all over again if it doesn't execute the t command.
==Example Programs==
===Cat Program===
 io
===Truth Machine (Needs non-interactive input)===
 i
 0 ot
 o
Category:Languages
Category:Joke languages
Category:Finite state automata
Category:Unusable for programming
Idvac

Idvac is a language created by User:FireCubez. Idvac stands for Increment and decrement values and compare. It is an OISC. Since the language only has one instruction by nature of being an OISC, the instruction name is inferred. A program can be in either source or compiled form.
== Source ==
An Idvac program's source code is a series addresses, separated by whitespace. Each address takes up a fixed amount of memory, which should be specified to the compiler by the user as a flag. The amount of addresses in a program must be a multiple of 2.
It is recommended for address sizes to be a power of 2 for storage in files, but they may be anything. Implementations are allowed to deny address sizes that are hard to implement.
The suffix for Idvac source code is .ivs
== Compilation ==
Compiling Idvac is very simple:
* First, there is a file header: the number of bits which an address consists of, followed by IVC. For example, 64IVC would be a header for a 64-bit address file.
* Then, addresses are read from the source file, and simply inserted into the file as binary values, little-endian.
The suffix for compiled Idvac is .ivc
== Execution ==
Execution is also very simple. Programs may be compiled to native executables for best performance, or emulated (interpreted). Either way, this is how execution is performed in pseudocode (assuming memory is initialized):
 address ip = *0;
 while(true) {
 if((***ip)++ == (***ip + 1)--) ip = ***ip;
 ip += 2;
 if(ip == 0) break;
 if(ip == -1) ip = input();
 }
Memory is an array of integers, the integers being the same size as the addresses. Whether the integers are signed or not is irrelevant, since addition and subtraction is identical on signed and non-signed integers. The instruction pointer starts at the value defined by the first address in memory.
== Special Addresses (memory mapping) ==
While there is no direct instruction for both IO and halting, these are memory mapped.
As seen in the implementation above, setting the instruction pointer to -2 (in 2's complement) will result in it being 0 after incrementation, which causes a halt. If the IP is -1 after incrementation, the IP will be set to the next chunk of input, where a chunk of input is min(8, addrsize) bits long. For example, if the input is 11110100 (little endian bits), and the address size is 5, the chunk will be 11110, and the next chunk will be 10000 (i.e. 1, converted to decimal using little endian).
As for output, setting address -1 (not the IP to -1) will print out a chunk (as described above) consisting of the IP's bits. Once we have enough chunks to go over 8 bits, those 8 bits are printed. For example, a chunk 11111 followed by a chunk 11100 (bits are little endian) would combine to be 1111111100 which is 8 bits. Those bits (11111111) will be printed and discarded, leaving 00. If a chunk 11000 were to come after that, we would have 0011000 (not 8 bits, so wouldn't print yet).
Category:Languages Category:OISC Category:Low-level
If(j)invert()if(l)change()if(q)input()if(t)output(x);

If(j)invert()if(l)change()if(q)input()if(t)output(x); is a joke language.
==Specifications==
If(j)invert()if(l)change()if(q)input()if(t)output(x); has 2 cells of memory and an instruction pointer. Both cells can store integers.
Instruction	Action
j 	If the cell is 0, set it to 1. Else, set it to 0.
l 	Shift the pointer to the other cell.
q 	Accept input and overwrite it at the selected cell. Integers other than 0 and 1 are accepted.
t 	Output the selected cell's value.
All other characters output themselves.
==Interpreters==
===Java===
This may not be accurate to the (likely) official C interpreter.
 import java.util.Scanner;
 public class jlfq{
 public static String interpreter(String code){
 Scanner input=new Scanner(System.in);
 int[] mem={0,0};
 int pointer=0;
 String o="";
 for(int i=0;il themselves, since it is the only way to have an integer in a cell other than 1 or 0.
 Heqtto Wortd
===Cat===
Using the instructions alone, a cat is limited to finite sequence of commands. Unless a looping command is implemented, cats are impossible.
Finite versions include this program,
 qtqtqtqtqtqtqtqtqtqtqtqtqtqtqtqtqtqtqtqtqtqtqtqtqtqtqtqtqtqt . . .
and this program.
 qlqltltlqlqltltlqlqltltlqlqltltlqlqltltlqlqltltlqlqltltlqlql . . .
The difference between both is that the latter program outputs 2 at a time while the former outputs 1 at a time.
===FizzBuzz===
See Quine for more details.
 1
 2
 Fizz
 4
 Buzz
 Fizz
 7
 8
 Fizz
 Buzz
 11
 Fizz
 13
 14
 FizzBuzz
 16
 17
 Fizz
 19
 Buzz
 Fizz
 22
 23
 Fizz
 Buzz
 26
 Fizz
 28
 29
 FizzBuzz
 31
 32
 Fizz
 34
 Buzz
 Fizz
 37
 38
 Fizz
 Buzz
 41
 Fizz
 43
 44
 FizzBuzz
 46
 47
 Fizz
 49
 Buzz
 Fizz
 52
 53
 Fizz
 Buzz
 56
 Fizz
 58
 59
 FizzBuzz
 61
 62
 Fizz
 64
 Buzz
 Fizz
 67
 68
 Fizz
 Buzz
 71
 Fizz
 73
 74
 FizzBuzz
 76
 77
 Fizz
 79
 Buzz
 Fizz
 82
 83
 Fizz
 Buzz
 86
 Fizz
 88
 89
 FizzBuzz
 91
 92
 Fizz
 94
 Buzz
 Fizz
 97
 98
 Fizz
 Buzz
===Quine===
Any message not using the commands j, l, q, and t is already a quine, since the default command for other characters is to output them. Examples include:
 7his is a 9uine
 7his is a1so a 9uine
As seen above, the latter 3 commands can be impersonated using 1, 9, and 7, respectively, while j can be replaced by ].
===Code fragment where ll can't be omitted without changing its behaviour===
Amazing. 
 qllt
Category:Languages
Category:Joke languages
Category:2014
Category:Implemented
Category:Total
Category:Low-level
Category:Unusable for programming
IfSetThenSet

IfSetThenSet is an minimalistic esolang with only 1 command. The memory contains 8 bits, either 1 or 0, the first bit being 1. If an certain bit is 1 or 0, then it sets another bit to 1 or 0. The format of the command is "[Memory location in binary to check][Value to compare (0/1)][Memory location in binary to set][Value to apply (1/0)]", or something like "00000000". For example, 01010010 means that if the third bit is set to 1 then set the second bit to 0.
==Notes==
*"- - - - 0001" (if CONDITION then set bit 1 to 1) sets the second bit to the user's input
*"- - - - 0000" (if CONDITION then set bit 1 to 0) ouputs the second bit.
*The command are separated with "-"
*The program loops when it reaches the finish.
=Example programs=
*AND (one time):
 00010001-00100101-00010001-00100101-00010010-01000011-00010000
*OR:
 00010001-00110101-00010001-01010011-00010000-00010100
*Truth-machine:
 01000001-01100000-00010101-00100111
==Interpreters==
 (TurboWarp interpreter, not including the main loop)
==Community==
If you have made an interesting program in this, edit the page an insert it below this text.
Category:Joke languages Category:Unusable for programming Category:2024 Category:Languages Category:Implemented Category:Finite state automata