nyuuzyou/wikis huggingface dataset:
I-ok

A small 1 digit esolang, for simple 1 letter usage.
This is still a W.I.P.
 
syntax	desc
i+ 	adds one
i++ 	adds two
i- 	subtracts one
i-- 	subtracts two
i* 	multiples by two
i/ 	divides by two
== Letters ==
Turning digit over 15 converts numbers into letters.
i+ i+ i* i* i* This would be 'a'
Letters range from 'a' to 'i' going over 24 turns result into null.
The same applies for going negative, special characters range from ! to ), going above 26 results in null.
i-- i* i* i* This would equal !
== Examples ==
=== h ===
i++ i++ i++ i++ i++ i++ i++ i++ i++ i++ i++ i+ displays h
=== ! ===
i-- i* i* i*
== External sources ==
i-ok interpreter
Category:2021
Category:Usability unknown
Category:Languages
IANAL

IANAL (I Am Not A Lawyer) is a programming language. Programs in this language are presented in the form of a legal contract, and they run with the aid of a human interpreter (preferably a lawyer) or a team of human interpreters working in parallel. IANAL code is very powerful and very flexible, which may lead to disagreements over its semantics. Ultimately, the formal semantics of IANAL are determined by the courts.
IANAL is Turing-complete and has built-in Machine Learning, Natural Language Processing, and Computer Vision features, such as the famous "I know it when I see it" rule.
== Adoption ==
IANAL is in widespread use today, and indeed most pieces of software contain a small amount of IANAL code. Many humans across the world go through an intensive multi-year study program to become competent programmers and interpreters of IANAL, and the IANAL programming career is strong -- although certified IANAL programmers tend to write in a more formal variant of the language called IAAL (I Am A Lawyer).
The cryptocurrency "Fiat Money" also has widespread adoption and was written in IANAL, though this was invented prior to the discovery of blockchain technology. The double-spending problem is solved either by passing around physical tokens ("Cash") or employing a central authority ("Bank"). Smart contracts written in IANAL are often backed by this cryptocurrency.
Category:Languages Category:Turing complete
IBC

IBC, which stands for Impose Bill City.
It was meant to never be programmed in, even though it technically is possible.
==Instructions==
The file will always delete itself after it is run.
Command	What it does
newline	If ever it is placed into the program, it deletes system32.
N 	Does a random instruction from brainfuck.
A 	It installs adware onto the computer.
==Examples==
===Hello, World!===
There is a 9.495e-64% chance that
NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN
will become a Hello, World! program. This is the most probable Hello, World! program known to exist in IBC.
===Cat program===
There is a 0.003% chance that
 NNNNN
will become a cat program.
===Delete System32===
===Enshittification Simulator===
There is a 0.19% chance that
NNAAAAAAAAAAAAAAAAAAAAN
will simulate enshittification.
==Turing-completeness==
If you run the N command enough, it will get the program you want.
==Implementations==
The User MatthiasChan is currently creating a[n] interpreter for this language that will allow you to run it, and will proceed to create a Hello World program.
Category:Languages Category:Nondeterministic Category:Turing complete Category:2019 Category:Probabilistic Category:Turing tarpits Category:Unusable for programming Category:Unimplemented
IBM 1401

The IBM 1401 is a historical computer announced by IBM in 1959.
Even though it was a real machine used for business purposes, it may be of interest to esolang enthusiasts, due to the unusual (to modern eyes) machine code.
Unlike most modern systems, machine code uses printable characters, with simple mnemonics. It uses decimal arithmetic, and variable word sizes.
== Hello world ==
(Hello world courtesy of http://simh.trailing-edge.com/software.html) 
The following would go onto a punched card, and loaded via the LOAD button on the card reader. Each line represents a single card.
,008015,022029,036043,050054,055062,063065,066077/333/M0762502F1.HELLO WORLD
=== Explanation ===
Hello world, with memory locations labeled below it:
,008015,022029,036043,050054,055062,063065,066077/333/M0762502F1.HELLO WORLD
00000000011111111112222222222333333333344444444445555555555666666666677777777778
12345678901234567890123456789012345678901234567890123456789012345678901234567890
The card loading process sets a word mark on memory location 1, and clears word marks elsewhere up to location 80. It then reads the card in and starts execution.
Each instruction must be on a word mark, and most instructions must have a word mark afterwards.
, is the set word mark instruction, and in 7 character form, does not need a word mark after it.
,008015 sets a word mark on location 8 and location 15.
,022029 can run because of a word mark set previously, and sets word marks on location 22 and 29.
,036043 sets word marks on locations 36 and 43.
,050054 sets word marks on locations 50 and 54.
,055062 sets word marks on locations 55 and 62
,063065 sets word marks on locations 63 and 65
,066077 sets word marks on locations 66 and 77.
/333 clears memory from location 333 to location 300.
/ uses a register that was set due to the previous /333 to clear from 299 to 200.
M076250 takes the data from 76 down to the next word mark descending (66) and copies it to 250 (going down)
2 prints the contents of memory locations 201-332.
F1 does control carriage 1 (??? is this effectively a newline?)
. halts.
==See also==
* IBM 140huh
Category:Languages Category:Before 1993 Category:Implemented
IBM 140huh

IBM 140huh is an esolang nearly the same as IBM 1401 machine code, as fed into the card reader.
However, unlike an IBM 1401, all commands must have a word mark following them in memory, including the command that adds word marks.
Therefore, it is impossible to run an IBM 140huh program, as there is no way to add the word marks that a normal IBM 1401 program would rely on.
Explanation of how an IBM 1401 boots from punched cards. In IBM 140huh, there is no exception for "Set Word Mark"
== Hello World (non-working example) ==
The below is Hello World for an IBM 1401 on punched card. It prints HELLO WORLD to the IBM 1403 printer.
,008015,022029,036043,050054,055062,063065,066077/333/M0762502F1.HELLO WORLD
As it starts, there is a word mark set on position 1.
,008015 sets word marks on positions 8 and 15.
This program does not work in IBM 140huh, as ,008015 needs a word mark after it (position 8), and there is none as it begins execution.
== Implementation ==
Implementation. The "1401" interpreter is actually an IBM 140huh interpreter.
=== Usage ===
If foo.txt contains an IBM 140huh program (with a newline afterwards)
sim> at cdr foo.txt
sim> set lpt default
sim> b cdr
results in the following error
Address register wrap, IS: 1 (DCW @,008015,022029,036043,050054,055062,063065,066077/333/M0762502F1.HELLO WORLD @)
Category:Unusable for programming Category:Implemented Category:Languages Category:Low-level
IDIJ

IDIJ (Increment Decrement If Jump) is an OISC by User:None1.
There is a tape with infinite cells and every cell is an unbounded signed integer.
The only command is:
 A B C D
Increment address A then decrement address B, then if address C is 0, jump to line D (1-indexed).
==Computational class==
Turing complete, because you can easily compile it from minsky machine. Let's use 2-register minsky machine as an example:
Let N be current line number:
Increment register A:
 0 2 0 N
Increment register B:
 1 2 0 N
If register A is 0, jump to somewhere, otherwise decrement register A:
 2 2 0 position
 2 0 0 N
If register B is 0, jump to somewhere, otherwise decrement register B:
 2 2 1 position
 2 1 0 N
Translation for minsky machines with more than two registers can be made using similar techniques.
Category:Languages
Category:OISC
Category:Turing complete
Category:2024
IDK

IDK is a joke language consisting of 1 instruction, 1 variable, and 2 registers.
IDK has a file extension of .idk or .IDK, usually .idk.
==Language==
Command 	Description
openC 	Starts program and must be called at the Beginning of File (BOF).
closeC 	Ends program and must be called at End of File (EOF).
execute 	Executes the value in an extract register.
openJump 	Loops to line defined by the value of an isolate register.
if 	Checks whether a variable is equal to the value in an extract register; then loops to line defined by isolate register.
pause 	pauses for one second.
Variable 	
movVar 	Creates a variable and overwrites it.
Register 	
extract 	Pops the value in a stack into an extract register, must be called to use an instruction. See also Instructions.
isolate 	Pops the value in a stack into an isolate register.
Stack 	
movLoc 	Pushes to the stack.
extractX 	Pushes to the stack with the value of an extract register.
varX 	Pushes to the stack; however from the rightmost of the stack with the value of a variable. See also the stack.
isolateX 	Pushes to the stack with the value of an isolate register.
Instruction	
1 	Exits program immediately
2 	Outputs the value in a variable.
3 	Reads input.
==Examples==
=== Hello, World! ===
 openC
 movLoc
 2
 extract
 movVar
 Hello, World!
 execute
 closeC
==External resources==
Bash (GrpeApple)
Category: Joke languages
Category: Stack-based
Category: Implemented
Category: 2021
Category: Languages
IDKHIW

===IDKHIW===
This is programming language made by R0fael
IDKHIW - I Don't Know How It's Working
This language uses 2 compilers:
compilerA and CompilerB
CompilerA is goes first.
You must type code with spaces and newlines(inspired from whitespace)
Here is a pointer that you have to pick the symbol to the next compiler
In the table and references "s" is space and "n" is a newline
Command	Description
ss 	Adding 3 to the pointer
sn 	Removes 2 from the pointer
nn 	Writes symbol from binary of the pointer value
The next compiler runs...
Command 	Description
- 	Adding 1 to the valueA
$ 	Removes 1 from the valueA
[space] 	prints character of the valueA
_ 	printing valueA
[newline]	prints character of the valueA; writes to valueA the integer input that asks.
[space] 	prints a [newline]
( 	swaps valueA and valueB
} 	writing to valueA the result of valueA + valueB
{ 	writing to valueA the result of valueA - valueB
[ 	writing to valueA the result of valueA * valueB
] 	writing to valueA the result of valueA / valueB
; 	writing to valueA the [valueA]th element in listC
: 	writing from valueA to the [valueB]th element in listC
3 	writing to booleanD the [valueA]th element in listF
& 	writing from booleanD to the [valueB]th element in listF
! 	writes to booleanD (not booleanD)
l 	writes to booleanD (booleanD and booleanE)
< 	swaps booleanD and booleanE
p 	stops the programm if booleanD is true, otherwise runs it again
This eso-language is hard.
This programming language includes everything to make own programming language, so easier to make own language, that code on that thing.
==Programs==
No programs for the moment
In the discussion write own programs!
Category:Languages
IDlang

IDlang is language derived from BF.
==Commands==
Command	Meaning
+ 	increment current cell
- 	decrement current cell
> 	move pointer to the right
< 	move pointer to the left
. 	output cell as number.(why you need outputing cells as characters?)
, 	input number and store it in current cell
! 	skip every instruction until next ! if 0
? 	skip every instruction until next ? if 0
^ 	jump to start of program if cell not 0
==IDmini==
IDmini is minimazisation of IDlang
===Step 1. Combining input and output(8 instructions)===
 +-<>;!?^
; is , when 0 and . otherwise
===Step 2. Combining > and +(7 instructions)===
 }-<;!?^
} is >+ in previous step
===Step 3. - deleted(6 instructions)===
 }<;!?^
You don't need - when cell is 8 bits
===Step 4. Combining } and !(5 instructions)===
 <;)?^
) is }!
===Step 5. Deleting ?(4 instructions)===
 <;)^
) will now skip next instruction if 0, so ? is unnesesary
===Step 6. Deleting ^(3 instructions)===
 <;)
After executing program will be run command ^
So command list is:
< 	move pointer to the left
; 	if cell is 0 input, else output
) 	move pointer to the right, increment cell and if it is more than 255 set to 0. Skip next instruction if 0
end of the program	if cell is not 0 back to start of program
 
==BITlang==
BITlang is another minimisation of IDlang.
===Step 1. make cells 1-bit long(8 instructions)===
 *<>.,!?^
No explanation needed.
===Step 2. memory-mapped IO(7 instructions)===
 *<>;!?^
if cell is not zero input number and store it in next 8 cells. If cell is zero output next 8 bits.
===Step 3. Make ! skip next command(6 instructions)===
 *<>;!^
! is now skip only next command, so ? is not necessary
===Step 4. Combine * and >(5 instructions)===
 <>;!^
> is *> in previous step
===Step 5. Combine < and !(4 instructions)===
 >;{^
{ is a <! in previous step
===Step 6. Combine { and ^(3 instructions)===
 >;]
] is interpretetated as ^ if there isn't another ] after. Otherwise it is interpreted as {.
===Translation from 1-bit IDlang===
From 1-bit IDLang to BITlang:
1-bit IDlang	BITlang
> 	>]] >
< 	]] followed by space
* 	>]] followed by space
! and ? 	>]] >]] after every command
^ 	]
From BITlang to 1-bit IDlang:
BITlang	1-bit IDlang
> 	*>
] 	^ if there isn't another ] after it. If there is, then <!
 
Category:Languages Category:Turing complete Category:Cell-based Category:Unimplemented
IEO-fork

IEO-fork is a fork of User:None1's project, Interpret Esolangs Online created by User:Ractangle. 
This was originaly a pull request to add 6 to Interpret Esolangs Online
==Added features==
===Languages===
This fork has 39 (or 37+2) languages. Two of which got ported to Interpret Esolangs Online due to the pull request
* Six
* >*&<<&^
===Features===
* Byte counter
* Run programs by clicking the output box
==Can help?==
You can technicaly make an issue in the repo or make a subtopic in my talkpage or make a topic in the talk page of this article
==See also==
* Interpret Esolangs Online
* Main page
Category:Implementations
IG

IG - Esoteric programing language by ChuckEsoteric08.
Language Named after 2 first commands that has been add.
==Description==
It has one accumulator. "Word" is any sequence of symbols seperated with space. Counting starts at 1.
 i - if STDIN is empty input and change accumulator to lenght of input².If STDIN is not empty print value of input, change accumulator by 
 lenght of input and set input to 0
 g [x] - goto word [x]
 ! [x] [y] [z] - if accumulator bigger than [x] goto word [y] else goto word [z]
 ~ - set accumulator to 0 ask user for input and set accumulator to inp and print acc to console
 ? - set accumulator random from 1 to acc³
 N - set accumulator to 0
 (space) - Split words
==Examples==
===Cat program===
 i g 1
==External resources==
Scratch Interpreter
Category:Languages Category:Low-level Category:Push-down automata
IHCBBTWAIABMSEYRACIRWYT

IHCBBTWAIABMSEYRACIRWYT (I Honestly Can't Be Bothered To Write An Interpreter All By Myself So Everytime You Run A Command It Runs What You Typed) is an interpreted esoteric programming language created by _hyperdawg. It is based on APLBAONWSJAS in the way that it invokes a separate interpreter instead of running one inside itself.
=Example Programs=
==Hello World==
Type a programming language name into IHCBBTWAIABMSEYRACIRWYT and do a hello world program in whatever language IHCBBTWAIABMSEYRACIRWYT comes up with. E.G. python THEN print("Hello World!")
==Cat==
Same as hello world, just invoke a Cat program in the language IHCBBTWAIABMSEYRACIWYT gives you.
==Nop==
nop
==Quine==
quine
==Quit IHCBBTWAIABMSEYRACIWYT==
exit
=Implementations=
IINC

IINC is an esoteric programming language by User:Zzo38.
==Syntax==
A program is a sequence of "lines", separated by any whitespace, not necessarily by newlines.
Each line is formatted as follows:
 Linenumber:ValueCommand
For example:
 20:35INC
Numbers (line numbers and values) are unbounded non-negative integers. Pairs of numbers can be encoded as a single one, their mingle.
Lines can be numbered in any order and any numbers can be skipped. They are executed in the order they are listed in the program. There must be no duplicate line numbers.
A number can be an expression, which is evaluated by the preprocessor:
* (n) is the initial value at the line numbered n, which has to be before the current line in the program.
* (n,m) is the mingle of n and m.
* An omitted number is the same as zero.
A command can be a command name or a list of commands in parentheses and separated by commas (such as "(OUT,20OUT,INC,(1,3)DEC)"). The commands in a list are executed in order when their line is executed. The numbers before the commands are added to the current line's value to find the value for executing that command. A GOTO command is only allowed at the end of a list.
Comments begin with * and last until the next actual newline character.
==Commands==
(Note: Any command that cannot be performed or whose parameter is invalid has no effect.)
The (Value) for a command is the value of its line, plus any value immediately before the command if it is in a list.
* INC: Increment the value at the line numbered (Value).
* DEC: Decrement the value at the line numbered (Value) if not already zero.
* GOTO: Go to line (Value).
* IN: Get a number from input and store as the value at the line numbered (Value).
* OUT: Output the number (Value).
* PUSH: Push the number (Value) to the stack.
* POP: Pop the stack and store the resulting number at the line numbered (Value).
* QUIT: End the program.
* MIN: Pop 2 numbers from the stack, push the mingled value.
* UN: Pop a number from the stack, unmingle it and push the 2 resulting numbers.
==Example==
 * This program inputs 2 numbers and adds them together.
 (0,1):((1,0)IN,(0,3)IN)
 (0,2):1PUSH
 (0,3):(PUSH,MIN)
 (0,4):(0,5)POP
 (0,5):GOTO
 (0,6):(1,0)INC
 (0,7):(0,3)DEC
 (0,8):(0,2)GOTO
 (1,0):(OUT,QUIT)
Category:Languages
Category:2006
Category:Unimplemented
IJL

IJL is a Interesting Not Not Joke Language.
An example program:
 print()
Outputs:
 ERROR!! CODE CORRECT!
This:
 SUM(1+1)
Outputs:
 600#
This:
 SUM(99+990000000)
Outputs:
 600##.#
A subset called 
 "" " ^ " 
 "" " || "
 /\
 FiReWork
Is to be made.
Is it a Joke language?
NO!
1+1=600# is a method of saying "NOT BINARY, 0 ZEROS"
The other example mans more than 2 zeros, non binary.
SIMPLE.
ILLGOL

ILLGOL is an esoteric programming language created by Chris Pressey in 2000, intended as a parody of "debugged-into-existence" programming languages -- languages which exist solely by virtue of the fact that there is a compiler or interpreter for them which works most of the time. It was followed by sequels Illgola-2, Illberon, and Open Sores ILLGOL##.
The ILLGOL family of languages is possibly the only one to have comic book superhero mascots. The documentation for Illberon consists largely of a single comic strip featuring two characters called Release Notes Girl and Captain Compiler.
==External resources==
* 
* link to ILLGOL-to-8086 compiler
Category:Stubs
Category:Languages
Category:Implemented
Category:2000
ILlogIc.

ILlogIc. is an esolang by User:Ϫ based on logic gates.
==Syntax==
* All variables start as false.
* Conditionals can have NOT, OR, XNOR, AND, and other logic gates.
==Commands==
 All Commands
Command 	Effect
Retrieve A 	Sets A to the user-input.
Out ABCD.. 	Outputs the binary number formed by A, B, C, D, etc...
If (conditional) 	Skips the next line if the condition is false.
A becomes (conditional)	Evaluates the condition and stores its result in A.
{(any string) 	Added after a line as a marker.
}(any string) 	Added after a line to signify that after you process this line you should go to the line with the {-marker and execute it, then keep going from there. If there are both }-markers and {-markers on a line, the {-marker goes first.
==Programs==
===Infinite Loop===
As a side effect of the marker system, there is no such thing as a simple infinite loop with no command. Therefore, we have multiple different loop types:
=====Output Loop=====
 Out A {Ϫ }Ϫ
=====Toggle Loop=====
 A becomes NOT A {Ϫ }Ϫ
=====Stasis Loop=====
 A becomes A {Ϫ }Ϫ
===0 to 16 looping counter===
 F becomes NOT F
 A becomes A XNOR F {loop
 B becomes A AND F
 C becomes B AND F
 B becomes B XNOR F
 D becomes C AND F
 C becomes C XNOR F
 D becomes D XNOR F
 Out ABCD }loop
Category:Languages Category:2024 Category:Unimplemented Category:Unknown computational class
INCAL

INCAL is an esoteric programming language by (presumably) User:Zzo38.
==Operators==
#	Number
<	Copy: Copies previous operand
>	Destroy: Destroys previous operand
-	Variable: Get the value of a variable
@	Centrifuge
*	CellularAutomaton
_	Store
?	Skip
;	String
^	Recall
!	Array
$	Swap
`	UnArray
%	Execute
+	Combine: Combines 2 8-bit values to a 16-bit value
[	BeginLoop
]	EndLoop
==Commands==
send 	Send to output
receive	Receive from input
store 	Store value in a variable
call 	Call a subroutine
return 	Return from a subroutine call
record 	Start recording changes of variables
stop 	Stop recording
rewind 	Rewind recording and put variables recorded to old values
accept 	Accept new values of variables and remove old value from recording
forget 	Discard entries from call stack
echo 	Echo a normalized form of a value to output
die 	Stop program
string 	Create string for using with $ operator
erase 	Erase a recording
object 	Create object
enter 	Enter an object code
exit 	Exit from an object code
bits 	Tell the bits of a number to the output
edit 	Self-modifying code
==Examples==
Hello World example:
 send,66#111#102#<101#42#93#101#120#102#110#43#
 die
Replace q with the value to check:
 68#q<@* = Return 1 if non-zero, or 0 if is zero
 51#q* = Bit-wise not of q
 240#q* = Half value of q
 170#q* = Double value of q
 102#q* = Intercal XOR operator
 136#q* = Intercal AND operator
 238#q* = Intercal OR operator
Interleave bits of 2 8-bit values (replace X and Y with the operands):
 24575#10239#4607#2175#1055#519#257#XY+@@@@@@@
==External resources==
* Download file 
Category: Implemented
Category: Languages
Category: Low-level
Category: Unknown computational class
Category: Unknown year
INCJ

The INCJ (pronounced INC-JAY) programming language is an OISC. It operates on a memory of signed unbounded integers. 
=== The pseudo-C definition ===
 Mem[a] += Mem[b];
 if (Mem[a] != Mem[c]) {
 goto d; 
 }
=== DJN equivalence ===
The following memory locations are defined:
* dec:-1 
* zero: 0
For every DJN command, "X Y", the INCJ command "Y dec zero X", can replace it.
This means INCJ is Turing Complete.
Category:LanguagesCategory:OISCCategory:Turing complete
INF)xO

INF>xO is an esoteric programming language made by User:AmNow. INF>xO was made so that you can have infinite output without loops.
== Commands ==
 Version 1.3
 €([a]’[b]… )
defines a N-dimensional vector. e.g.: €(z’34’|’)
note: INF>xO uses base 37 ([0-9][a-z]Æ, | (pipe) references infinity)
To declare/set a variable, use:
 [name]…[value]
To reference the value in one, use:
 :[name]:
To get a single value from a vector (note: zero-indexed):
 [vector]{[index]}
 +,-,* and / do math: e.g.: 2+2
+ can be used for concatenation of vectors: e.g.: €1’2+€3’4 results in €1’2’3’4.
* can be used for multiplication of vectors e.g.: €35*| results in €35’35’35…
 p;[object]; Output as Unicode.
 P;[object]; Output as base 37.
 R;[object]; Output as base 10.
 i Input a vector in Unicode.
 I Input vector in base 37
 Ī Input vector in base 10
 j Input Unicode character and use the ID.
 J Input number in base 37
 ~ Input number in base 10
 ¥[cnd]«[code]» while cnd returns true, do code.
 ;[cnd]^[true-code]«[false-code] if cnd is true, do the true code, else do the false code, [false-code] is optional.
 \ End program.
 §[comment] Comment
 @ Reference the program in a vector.
== Programs ==
=== Spam #s ===
 p;€(z)*|;
=== Truth Machine ===
 ;~==1^ § check if input is 1
 p;€(1b)*|; § output one forever if it is 1.
 « § else
 R;0; § output 0
 » § end
=== Adder ===
 ¥1==1^R;~+~;«
==== One time ====
 R;~+~;
=== Quine ===
 p;@; § This Quine cheats. 
== Computational Class ==
INF>xO is Turing complete as seen here:
 BF INF>xO
 Init s…€(0)*|
 p…0
 
 + s{:p:}…s{:p:}+1
 - s{:p:}…s{:p:}-1
 < p…:p:-1
 > p…:p:+1
 . p;s{:p:};
 , s{:p:}…j
 [ ¥s{:p:}!=0«
 ] »
Category:Turing completeCategory:2021Category:UnimplementedCategory:Languages