nyuuzyou/wikis huggingface dataset:
InstructionPointerBF

InstructionPointerBF is a PocketBF variant.
There are only 2 instructions, so it can take instruction in binary.
The motivation for creating InstructionPointerBF is to allow Brainfuck code to compressed by converting characters to InstructionPointerBF, so that no ASCII character is wasted.
==Commands==
Command	Description
0 	Increments instruction pointer by 1
1 	Executes instruction at pointer as PocketBF code
A PocketBF command selector, starting at the instruction =, selects upon each encounter with a zero-bit (0) the next command, following this ordering:
 = + > | ;
Having reached the desinent member (;), the selector wraps around, starting again with =.
A description of these instructions can be found in the article here.
A more explicit illustration of the command selector's advance shall be provided below:
Order of the PocketBF command selector
Current PocketBF command	=	+ 	>	 	;
Next PocketBF command 	+	>	 	;	=
==== Examples ====
===== Cat Program =====
01001010
10000100
00100000
On the last line, 5 zeros had to be padded to make a complete byte.
While slightly inefficient, a Cat program is only 3 bytes, compared to Brainfuck's 5 bytes. If the "junk bits" are removed, a Cat program is only 19 bits, compared to Brainfuck's 40. So significant compression has been achieved. 
===== Note: =====
I think it is more efficient to iterate through PocketBF's instructions that Brainfuck's or TinyBF's, but I will have to test to see if there is a better language to have the pointer point to.
==Examples==
===Cat program===
In the following is an infinitely repeating cat program implemented:
 01001001010000100001010000101000100101001001010000100010
==Interpreter==
* Common Lisp implementation of the InstructionPointerBF programming language. The program also contains a PocketBF interpreter, given their consanguinity.
Category:Languages Category:Brainfuck derivatives Category:Brainfuck equivalents Category:Turning tarpits Category:Implemented
Instructistuctisurcticitstucrit

instructistuctisurcticitstucrit is a language where you have to code in one program to code in another etc. to finally get to brainfuck.
== how it works ==
code a befunge program
read the stack:
...987654321
where 1 is top
this should code into a deadfish layer like this:
 1 i
 2 d
 3 s
 4 q - repeat previous instruction 9 times
 5 j - add to tempcount
 6 c - clear tempcount
 7 t - subtract 10^tempcount
 8 b - add 10^tempcount
where the number at the end of the program is interpreted into brainfuck like this:
 1 +
 2 -
 3 <
 4 >
 5 [
 6 ]
 7 .
 8 ,
and 9 0 are nops.
== cat ==
 11v >65v
 3 >35577v 8
 2 7 @
 3 ^<
 2
 >132v
 4
 ^<
== ascii loop ==
 v v68<
 1>355 ^
 1 7
 41 @
 >1v
 13
 ^<
Category:Languages Category:Two-dimensional languages Category:Brainfuck derivatives Category:2024 Category:Unimplemented
Instructructinstructistructististuctistuctistuctuctistuctistuctisuctisuructistuctisurctisurctisurctisurcticticiciticitsurcticitststurcticitstucitstucrcticitstucritstucritucrit

instructructinstructistructististuctistuctistuctuctistuctistuctisuctisuructistuctisurctisurctisurctisurcticticiciticitsurcticitststurcticitstucitstucrcticitstucritstucritucrit (or instructuquerque if your a NOOB and cant pronounce instructructinstructistructististuctistuctistuctuctistuctistuctisuctisuructistuctisurctisurctisurctisurcticticiciticitsurcticitststurcticitstucitstucrcticitstucritstucritucrit) is a derivation of instructistuctisurcticitstucrit that is MUCH more insane. so insane, in fact, many instructructinstructistructististuctistuctistuctuctistuctistuctisuctisuructistuctisurctisurctisurctisurcticticiciticitsurcticitststurcticitstucitstucrcticitstucritstucritucrit programmers have died of the neurons in their brain getting too overcharged from the language and its specs.
== commands ==
ok so you know how instructistuctisurcticitstucrit is in befunge right? assume the @ is at the end and now its a string of numbers.
put that string of numbers to the right of a decimal point (yes, all of them), find the fraction that is x/10^y, convert to binary, then take that as decimal (9bA -> 1001b2 -> 1001bA)
then, program a brainfuck program that adds the reciprocals of the denominator and numerator together. the order HAS to be n then d.
then, program a instructistuctisurcticitstucrit program that emulates that brainfuck program.
== examples ==
NO!!!!!!!!!!!!!!!! ANYONE WHO PROGRAMS THIS IS COMPLETELY ABSOLUTELY AND UTTERLY INSANE!!!!!!!!!!!!!!!!!!!!!!!!!!!!!1!
category:joke languagescategory:2024
InterNet

InterNet is an esoteric programming language invented by User:A that relates to the net of a cube. It is designed to be really hard to program in.
==Nets of a cube (list of commands)==
@
@@@@
@
@
@@@@
 @
@
@@@@
 @
@
@@@@
 @
 @
@@@@
 @
 @
@@@@
 @
@@
 @@@
 @
@@
 @@@
 @
@@
 @@@
 @
@@
 @@
 @@
This cannot be fit into a 3x4 grid, so it will be ignored:
@@@
 @@@
This language begins with the first net mentioned.
Also, there is a "block-pusher" to push the squares of the net apart. A command will be entered if the current state is a valid net of a cube. The block-pusher starts at line 1, column 1, facing right.
==Syntax==
0: Turn right.
1: Move the block that the block-pusher is currently standing a unit of the block pusher's direction.
If there is a block at that direction, move the block-pusher 1 unit to that direction instead of moving the blocks.
Note that if the block-pusher formed another net in the process of executing, that command will be entered instead of the desired command.
==Example==
@
@@@@
@
to
@@
 @@
 @@
10101010101000110101010101011010101011010101101010001
==Commands==
@
@@@@
@
@
@@@@
 @
@
@@@@
 @
@
@@@@
 @
 @
@@@@
 @
 @
@@@@
 @
@@
 @@@
 @
@@
 @@@
 @
@@
 @@@
 @
@@
 @@
 @@
These correspond to the nets above:
:
Reset all digits in the pool to 0 
^ 
Flip the digit at the pointer 
! 
Output the pool 
<
Move the pointer to the left
>
Push the character into the queue
;
Pop a character from the queue
+
Add the frontmost 2 numbers and push it
-
Subtract
'
Pop a value from the queue and set it as the pool
?
If the front of the queue is nonzero, execute the next command.
The whole program is executed inside an infinite loop. If the user tries to pop an empty queue, the execution stops.
Category:Languages
Category:2019
Category:Unimplemented
InterWOEven

InterWOEven is an esoteric programming language designed to have a really unique execution style and really difficult to use. Programs in InterWOEven are, as the name suggests, just woven parentheses and brackets.
= Syntax =
The program is converted to a graph. Matching parentheses/brackets correspond to a node and how these matchings wove dicates what type of connections (if there are any) exist between these nodes.
In this example: '{(})' the two nodes partially contains each other. Meanwhile in this example: '({})', one node fully contains the other.
Each nodes holds a value, initialized to 1. Much like Brainfuck, InterWOEven interacts with a tape. Depending on the value of the first node, the one corresponding to the first open parenthesis/bracket and its partner, an instruction is executed:
Value	Effect
14 	Increment
31 	Decrement
43 	Move tape pointer to the left
47 	Move tape pointer to the right
53 	Input
56 	Output
61 	Set the value of first node to the value of the current cell
62 	Halt
After an instruction is executed, the node values are updated with this update rule: v <- (v + F)^P mod 101.
F is the sum of the values of the fully contained nodes.
P is the sum of the values of the partially contained nodes.
= Interpreter =
An implementation can be found here
Category:Usability unknown
Category:Languages
Category:Implemented
Category:Cell-based
Category:2024
Interdemento

Interdemento is a language concepted by User:Jabutosama. It is a rather simple language, or it should be one.
==Basics==
Programs should be compiled but actually only compile on run time. Also it should support unicode and ansi, but supports 7-bit ascii only. Reason to this is unknown. One could technically use any file with .itd as extension type for the language files but only foo.idt is allowed. This is because typo and poor design of the compiler.
Interdemento should be functional language but its actually just imperative. 
Following statements and structures are built-in:
Command 	Meaning 	Note
let x y 	allocates value y on x for current context. 	strings are only value you can make.
if x y z	returns y in case x is "true" and z if its false. 	even if its false, z is never returned but "0x33" instead.
same x y	returns "true" in case x and y are same. otherwise "false". 	cannot stack same inside another one.
map x y 	maps a function x to all elements of y 	this one actually works.
[ ... ] 	list literal. forms a list. 	this randomly shows up an error for some reason.
{ ... } 	sub-field. when referring to it as a value, code inside is executed, and first return or yield is the result.	name errors for some reason never show up from sub-fields.
return 	used to make current sub-field to identify a value. 	this works too?
yield 	same as yield, but block state is not changed, instead continued when recalled 	this wont work at all. play with return instead.
Category:Joke languagesCategory: Languages
Interfacefactory

in interfacefactory(made by User: Yayimhere) you use diffrent esolangs for diffrent parts of you code or "the factory". you start with the middle section where you write [] inside the []'s you put in piet code. on [ there is input and ] is the output. on the left side of the input you use factory and when the piet has handled that number to do any io you use puredata then to do calculus operations or https requests you use hofstadter connected to something between puredata and piet. whats between is Ensemencer. you put # in front and end of factory code and you put & around puredata code and you put / around hofstadter and you put > in front and < in the back of Ensemencer code. to connect things you use ascii dots code to move a dot with whatever the code outputs. this esolang is theoretical and not implemented
Category:Languages Category:Ideas Category:Unimplemented
Interfrac

Interfrac is a declarative esolang. It was discovered by User:Orby in 1994.
==Introduction==
In 1994, at the tender age of ten, I made a startling discovery about fractions. They tried to correct me, but I knew in my heart I had discovered something huge. It is a fact that many school children realize. The authorities have been repressing this knowledge for generations. Interfrac is the guiding beacon that will liberate us all. Interfrac is the first programming language that treats fractions how we all know they ought to be treated:
 (a / b) + (c / d) = (a + c) / (b + d)
They told you it was wrong, but I am here to share the truth. An Interfrac program is a list of fractions. If those fractions can be added correctly to (n / n) where n is any integer, then the integer n is accepted by the program. Repetitions are allowed.
Edit: There is a proof that the formula is invalid.
==Examples==
An example of an Interfrac program is
 -10/20, 10/-5
Notice that -10/20 + 10/-5 + 10/-5 = (-10 + 10 + 10)/(20 + -5 + -5) = 10/10. Therefore, the input 10 is accepted by the program. In fact, all positive multiples of 10 are accepted by the program. Another example:
 -2/5, 1/-7, 1/-3, 1/-2
Notice that -2/5 + -2/5 + 1/-7 = (-2 + -2 + 1)/(5 + 5 + -7) = -3/3 does not mean -3 is accepted. However, -2/5 + 1/-3 + 1/-2 = (-2 + 1 + 1)/(5 + -3 + -2) = 0/0 means 0 is accepted. Another way of saying this is to say that this program halts on empty input.
==Implementation==
Here's an implementation of the logic behind Interfrac, written in Brachylog version 2. (However, because Brachylog isn't very good at parsing, it takes the program using a different syntax, [[_10,20],[10,_5]].) The program is given as a command-line argument, the input on standard input. (You can also use I as the input, and then the interpreter will print some number that would be accepted.)
 ~{~h=∋ᵐ\+ᵐ=h}
Try it online!
==Computational class==
Interfrac is NP-complete:
* Interfrac is capable of solving the wikipedia:subset sum problem, and thus is at least NP-complete;
* The fate of Interfrac programs can be predicted via wikipedia:integer linear programming, and thus Interfrac is at most NP-complete.
==See also==
* Fractran an imitation Interfrac perpetuated by the authorities.
* INTERCAL is the second greatest programming language.
Category:Joke languages
Category:Declarative paradigm
Category:Implemented
Category:2019
Category:Languages
Intermediate language

An intermediate language, in the context of esolangs, is a language most commonly used to aid translation from one language to another. Intermediate languages are often used just once per specific proof, and while quite often esoteric in themselves, they are seldom meant to be considered equal to well-designed esolanguages. Intermediate languages are often sketched up relatively quickly, are loosely defined (with many undefined features), and are not quite as interesting on their own (nor are they meant to be). A common trait is that they have very specific rules and limitations, which arises from their role as a step in the translation chain. Interestingly, in their intermediary role, they are likely to have some traits of both languages, the one that translates into them and the one they translate into.
==Some examples in alphabetical order==
* Black Turing-completeness proof uses Exeter. Minsky machine is translated into Exeter which is translated into Black.
* Forte Turing-completeness proof uses Ectoforte. Minsky machine is translated into Ectoforte which is translated into Forte.
* I/D machine Turing-completeness proof uses ErrorBucket. Cyclic tag is translated into ErrorBucket which is translated into I/D machine.
* Strelnokoff Turing-completeness proof uses Alternating 1-based Minsky machine. Minsky machine is translated into A1MM which is translated into Strelnokoff.
Category:Concepts
Interpret

= Everything =
Interpret is a metaprogramming language that uses reduction
== Stuff ==
=== Types ===
write types = [<somthings>] to make the types
 types = [
 eval x,
 app a b,
 Z,
 S,
 F x,
 ]
=== Reduce ===
For any things that contain inputs, (like the App function in the previous example), you can write a reduction, "<func> = <reduce>"
 eval x = x
 eval (app I x) = eval x
 eval (app x y) = app (eval x) eval (y)
 eval (app S x) = F (x)
=== Tests ===
Test by doing "test <something> (<expected>)?"
 test (app I I)
 test (app S Z) (F Z)
Category:Languages
InterpretMe

InterpretMe is a joke language created by User:Challenger5. The language is as follows:
*	Accept input and interpret it as InterpretMe code
Any other characters are silently ignored as comments.
A self-interpreter in this language:
 *
== Interpreters ==
=== Python 3 ===
 def interpret_me(code):
 for char in code:
 if char == '*':
 interpret_me(input('Please enter some InterpretMe code\n> '))
golfed version by User:Ractangle:
 def im(c):
 for _ in c:im(input())if"*"in _ else...
=== Thue ===
 *::=:::
 ::=
 *
=== JavaScript ===
 function interpret_me(code)
 {
 for(i = 0;i < code.length();i++)
 {
 if(code[i] == "*")
 {
 interpret_me(prompt("Please Enter Code Here."))
 }
 }
 }
Golfed Version
 function a(b){for(i=0;i
function interpret_me(code)
 for star in code:gmatch("%*") do -- saves an if statement
 interpret_me(io.read())
 end
end
More golfed version:
 function im(c)c:gsub("*",function()im(io.read())end)end
Category:Languages
Category:Joke languages
Category:2016
Category:Unusable for programming
Category:Finite state automata
Category:Implemented
Interpret Esolangs

Interpret Esolangs is an esolang that interprets many esolangs. It is invented by User:None1.
==Commands==
Interpret Esolangs programs are in one line, that consists of lowercase commands separated by spaces.
There are these commands:
brainfuck, interprets brainfuck.
befunge, interprets befunge.
chicken, interprets chicken.
witespace, interprets whitespace.
no., interprets No..
nope., interprets Nope..
text, interprets Text.
interpretme, interprets InterpretMe.
self, a self interpreter.
==Example Programs==
===Print Nope.===
 nope.
===Cat Program===
 text
===self interpreter===
 self
===Print No.===
 no.
===brainfuck interpreter===
 brainfuck
==Computational class (?)==
It is not Turing complete, but since it can write a brainfuck interpreter, it is ℒ-complete.
Category:Languages
Category:Joke languages
Category:Unusable for programming
Category:Unimplemented
Category:Unknown computational class
Interpret Esolangs Online

Interpret Esolangs Online is a project created by User:None1, it is a webpage that allows you to run esoteric languages online.
==Introduction==
Interpret Esolangs Online interprets esolangs in client-side JavaScript. It currently supports these 40 esolangs:
* 6
* Alphuck
* APLWSI
* Arithmetic
* B2C
* Befunge-93
* Brainfuck+2
* Brainalpha
* !!brainfeed
* brainfuck
* Chicken
* ><x>
* Deadfish
* ›*&«&^
* Hello
* Hello++
* HQ9+
* HWorld
* Kipple
* <stack>
* Nil
* No.
* Nope.
* oOo CODE
* PlusIntMinus
* PlusIntOutput
* PlusOrMinus
* PlusOrOutput
* Poetic
* pRINT
* Quine (programming language)
* Random Brainfuck
* ReverseFuck
* Self-modifying Brainfuck
* Self-modifying Brainfuck#
* Text
* Weeeeeeeeeeeeeeeeeeeeeeeeeeeeee
* Welcome to Esolang, the esoteric programming languages wiki!
* Wizzcake
* Wizzcake+
The interpreters are all written by User:None1 except for the Arithmetic, Wizzcake, Wizzcake+, 6 and ›*&«&^ interpreters.
==Note==
Due to the restriction of GitHub Pages, if you want to create a permanent link of your program, the program shouldn't be too long, or you can manually download the source code of the webpage and deploy it in somewhere else that doesn't restrict URI length. There is no longer limit on URL length because the hash of URL is used instead of search now!
==How to help==
If you found a bug, you can write in the talk page or post an issue or send a PR at GitHub.
If you want to add esolangs, you can write in the talk page or post an issue at GitHub. If you write in the talk page, you can include an interpreter (preferably client-side JavaScript) along with the name of language if there is one. BUT REMEMBER, THE INTERPRETER YOU INCLUDE MUST BE PUBLIC DOMAIN!
If you want to collaborate, write in the talk page.
==External Resources==
* The page
* The page at replit 
* The page at vercel (Confirmed to work, but not latest)
* The source code at GitHub.
Category:Implementations
Interpreter

An interpreter is a program that executes a program written in the language it interprets.
Interpreting a program is less efficient than running a version that has been compiled to machine code, but it is more portable and often easier. It can also be faster than compiling if the compilation time is taken into account.
Most esoteric programming languages are implemented with interpreters, mostly written in non-esoteric languages. However, it's not unknown for esoteric languages to have interpreters for them written in other esolangs (brainfuck or some variation of it is a popular one, being a common way to prove the Turing-completeness of a new language by simulation), and a special kind of interpreters, self-interpreters, written in the same language. For different esolang interpreters written in other esolangs, see EsoInterpreters.
==See also==
* EsoInterpreters
* Compiler
* Parrot - a virtual machine supporting some esoteric languages
Category:Concepts Category:Program forms
Interrobang

= Overview =
Interrobang is a simple Tape based language aiming to balance simplicity and ease.
Symbol	Interrobang
l 	Move tape pointer left
r 	Move tape pointer right
[ 	If the current cell is 0, skip to it's closing bracket
] 	If the current cell is 0, skip back to it's openning bracket
? 	Input a character. It's ascii value will be put onto the cell
! 	Output cell value as an ascii character
; 	Input a number to the current cell
: 	Output current cell as a number
Another feature is the ability to write strings and numbers directly on the tape. To write a string to the tape you just put something in quotes, and when the code pointer hit's it, it'll be put on the tape. The characters are put on in reverse order; so if you were to put "abc" onto the tape, cell 0 would be c, cell 1 would be b and cell 2 would be a. This is so it's easier to print out. The tape pointer is moved when putting strings onto it
= Code Examples =
=== Hello, World! ===
 "Hello, World!"{!l}
This program works by printing each character untill it finds a 0, and since the tape loops around, it will find the 0 at the end of the tape.If you wanted to have text not take up more then one cell you could very well put each character and print each individually "H"!"e"!"l"!"l"!"o"!","!" "!"W"!"o"!"r"!"l"!"d"!"!"! This works because putting a single character on the tape doesnt move the tape pointer at all.
=== Even or Odd ===
 ;r[l-[r1l++]-[r2l+]r]
 -["Odd!"{!l}-]
 -["Even!"{!l}-]
This works by taking a number input and negating it twice each loop. Within each loop it's checking if it's 0 or 1, and if it is it escapes the loop. If it's Odd it'll escape the loop with a 1, and if it's Even it'll escape the loop with a 2. These two cases easily testable with just a []
=== Truth Machine ===
 ;:-[+:-]
= Extra Notes =
* The name of this language comes from the character "‽" which is called an interrobang. This character relates to this language as a simple cat program can be wrote as just ?!
Category:Cell-based Category:2024 Category:Turing complete Category:Implemented Category:Low-level
Interstack

Interstack (formerly Brainstack (nothing to do with Brainstack)) is an esolang made by User:PythonshellDebugwindow.
==Overview==
Interstack is a stack-based language with some influence from brainfuck. Its only value storage areas are the stack and the value cell; the stack can hold infinite values, while the value cell, which is used for operations such as input and output, can hold only one value. All Interstack values are wraparound integers from 0 to 255. Each character is one command.
==Commands==
Command	Effect
+ 	Pushes the value in the value cell to the stack, then set the value cell to 0
^ 	Pops the value at the top of the stack into the value cell (undefined behaviour if the stack is empty)
@ 	Peeks the value at the top of the stack into the value cell (undefined behaviour if the stack is empty)
% 	Switches the value at the top of the stack with the value in the value cell; if this is used more than once a . is needed at the end of the code
_ 	The opposite of ^, sets the value at the top of the stack to the value cell (doesn't push, just sets), then sets the value cell to 0
~ 	Flips the stack (the first value becomes the last, the second becomes the second-last, etc.)
* 	Sets the value cell to 0
# 	Sets the value cell to 65
? 	Get a line of user input, then set the value cell to the sum of all the input characters' ASCII values, minus the trailing newline
! 	Outputs the ASCII value of the value cell, which keeps its value
. 	Ends the code early; only necessary to terminate if more than one '%' is used
< 	Decrements the value cell by 1
> 	Increments the value cell by 1
& 	Adds the value cell to the value at the top of the stack, then sets the value cell to 0
( 	Opens for loop, loops value in value cell times (if the value cell changes, the loop's number of iterations doesn't, e.g. #(*) loops 65 times)
) 	Closes for loop
; 	Ends for loop early
All other characters are ignored.
==Examples==
===Hello World===
 #>>>>>>>!>>>>>>>>>>>>>>>>>>>>>>>>>>>>>!>>>>>>>!!>>>!*>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>!#>>>>>>>>>>>>>>>>>>>>>>!>>>>>>>>>>>>>>>>>>>>>>>>!>>>!<<<<<<!<<<<<<<<!
===Cat program===
Loops 2554 times. Input one character at a time.
 <((((?!*<))))
===Add two inputs===
Input two characters, one at a time.
 ?+?(^>+)^!
==Computational class==
As Interstack can only execute bounded for loops, it is total, and therefore not Turing-complete.
==External resources==
* Rust interpreter 
Category:Languages Category:2019 Category:Implemented Category:Stack-based Category:Total