nyuuzyou/wikis huggingface dataset:
Implicit loop brainfuck

implicit loop brainfuck is yet another brainfuck derivative by User:Transoptimal.
The original idea that inspired implicit loop brainfuck was:
 esolang where the only conditional is smth like "skip next instruction if [condition]" and loops are achieved by the entire code being executed in a loop until an explicit halt
== Differences ==
These are the differences between implicit loop brainfuck and brainfuck.
Command	Description
[ 	Jumps past the next (not the matching) ] if the current cell is 0. Every program that contains a non-zero amount of [ instructions must contain at least 1 ] instruction.
] 	Does nothing, apart from serving as a target for a [ instruction.
{ 	Has the same rules as [, except it jumps to and requires } instead of ], and its condition is the current cell not being 0.
During execution, the source code is treated as if it repeats infinitely; the instruction pointer loops back to the start when reaching the end of the code, and [ & { instructions at the end of the code can correspond to ] & } instructions at the start.
== Examples ==
Note that since there currently does not exist any implementation of implicit loop brainfuck, all of these are untested.
=== Cat ===
 ,{#}.
=== Truth machine ===
 {,.------------------------------------------------{#}++++++++++++++++++++++++++++++++++++++++++++++++.------------------------------------------------
=== Count down from number ===
 {,}.-{#
==Interpreter==
* Common Lisp implementation of the implicit loop brainfuck programming language.
Category:Languages Category:Brainfuck derivatives Category:Cell-based Category:Low-level Category:Implemented
Implieses

Implieses is a Zero Instruction Set Computer created by Calvin Games and rdococ on February 16, 2017. It is Turing complete because it is equivalent to a 2-tag system.
== Description ==
The computer state is a string of bits P.
P0 is the initial state.
If the first bit in Pn is 0 the computer halts and outputs the successive bits in Pn.
If the length of Pn is odd then 0 is added to the end of Pn.
The new state Pn+1 is the odd bits of Pn → the even bits of Pn.
The computer repeats this process until it halts.
== Programs ==
Hello World! (Outputs the ASCII code for the string "Hello, world!")
 Initial State:
 0 01001000 01100101 01101100 01101100 01101111 00101100 00100000 01110111 01101111 01110010 01101100 01100100 00100001
XOR (Outputs a XOR b)
 Initial State:
 11111111 11111110 ab101110 1111ba10
==Interpreter==
* Common Lisp implementation of the Implieses programming language.
Category:Languages Category:2017 Category:Turing complete Category:Implemented Category:Output only
Impossible.bf

Impossible.bf is invented by User:Yes and will make you bite the dust when it comes to programming.
== The impossibleness ==
To convert a bf program into Impossible.bf, run the program through a md5 algorithm backwards.
e.g., the program ,[.,] will go in as ],.[,
Then, the md5 hash will be converted to ascii values and then those would be converted to hex values.
The binary values of that is the valid Impossible.bf program.
== Point ==
So one day User:Yes was messing around on esolang and found this and decided to make it more impossible (especially with comments) and made this.
== Examples ==
Cat program
00111001
00110111
00100000
00110101
00110010
00100000
00110101
00110101
00100000
00110100
00111000
00100000
00111001
00111000
00100000
00110100
00111001
00100000
00110101
00110011
00100000
00110001
00110000
00110001
00100000
00110101
00110011
00100000
00111001
00111001
00100000
00111001
00111001
00100000
00110101
00110001
00100000
00110101
00110101
00100000
00110101
00110100
00100000
00111001
00111001
00100000
00111001
00110111
00100000
00110001
00110000
00110000
00100000
00110101
00110000
00100000
00110001
00110000
00110001
00100000
00110001
00110000
00110001
00100000
00110001
00110000
00110010
00100000
00110101
00110000
00100000
00110101
00110101
00100000
00110101
00110101
00100000
00110101
00110101
00100000
00111001
00111001
00100000
00110001
00110000
00110000
00100000
00111001
00110111
00100000
00110101
00110101
00100000
00110100
00111001
00100000
00110100
00111000
00100000
00110101
00110100
Category:Joke languagesCategory:LanguagesCategory:Brainfuck derivativesCategory:Unusable for programming
Improbable

Improbable is a register- and tape-based esoteric language focusing on succinctness.
A tape is called the datastore, and is 256 bytes long. The register is one byte. There are 256 tapes, for a total of 64k bytes.
==Instructions==
Command 	Use
=H 	Set register to byte
-FF 	Set register to byte by hex code
ps 	Print a character
pi 	Print an integer
pl 	Print a line separator (platform-dependent)
r 	Read a character from standard input
[ 	Save IP to register
] 	Read IP from register
S 	Save register to pointed-to datastore
G 	Load pointed-to datastore to register
> 	Move pointer right
< 	Move pointer left
^00 	Set pointer value (e.g. to 0)
@example 	Declare a label
!example 	Jump to a label
?00=example 	Jump to a label conditionally (hex value to compare, and = for equal or ! for not equal)
:+03 	Arithmetic (such as adding 0x03) to the register
; 	Exit, using register as exit code
X00 	Set tape number to use for datastore
{thing =H } 	Declare a function (e.g. named 'thing')
%thing 	Call a function
`Hello, world!`	Print some text
# STUFF # 	Insert a comment
==External links==
* Interpreter (Python 3) and specification/tutorial (PDF) tarball 
Category:Languages Category:Cell-based
Imput

imput is an esoterical programming language based on a misspelling of the word input. It is turing complete because it has every BF command.
==Commands==
Command 	Description
Increments the current cell by one, as in BF.	
Decrements the current cell by one, as in BF.	
< 	Moves the cell pointer one step to the left, as in BF.
> 	Moves the cell pointer one step to the right, as in BF.
, 	Queries the standard input for an ASCII character and stores its code in the current cell, as in BF.
. 	Prints the character whose ASCII code equals the current cell value to the standard output, as in BF.
[ 	If the current cell value equals zero, jumps forward to the matching ], as in BF.
] 	If the current cell value does not equal zero, jumps back to the matching [, as in BF.
imput 	Asks for input.
oumput 	Prints the last input.
ounput 	Prints the first input.
kiwi 	Prints the text “kiwi”.
ouput(argument) 	Prints the argument to the standard output.
==Examples==
===Hello World===
 ouput("Hello, world!")
===Cat===
 imput
 oumput
===Kiwiscript===
 kiwi
===Greeting===
This program queries the user for their name and prints a greeting incorporating the same:
 ouput("Please enter your name: ")
 imput
 ouput("Hello, ") oumput ouput(". How are you?")
==Interpreter==
* Common Lisp implementation of the imput programming language.
Category:LanguagesCategory:2023Category:ImplementedCategory:Brainfuck derivatives Category:Turing complete
InPro

InPro (Infinite Program) is a brainfuck derivative by User:ChuckEsoteric08
==Description==
The programs in the language are infinite, and thus it it needs to be run using a REPL. In this version while loop [...] is instead an if statement, which runs the code inside only if the cell is not 0. It would also make it easier to implement rather than normal brainfuck.
==Computational class==
We can execute same program over and over again to simulate infinite loop, making it Turing-complete. Howhever the author is not sure whether it really counts or not.
==See also==
*Transfinite program
Category:Languages Category:Unknown computational class Category:Unimplemented Category:Brainfuck derivatives Category:2024
InSpace

InSpace is a programming language that was made by Zayne for a Code Golf contest (that failed horribly).
== Commands ==
() is required
[] is optional
* pluto (\33) - prints what ever the ascii character code is on the screen (pluto only supports ASCII character codes in decimal)
* asteroid (a) (1) - sets variable a to 1 (only works for integers)
* comet (a) (testing) - sets variable a to testing (only works for strings)
* earth (a) - prints value of variable a to the screen (works with integers and strings, ASCII codes don't work.)
* sun (v([inputs])) - starts the definition of function v
* sun end (v) - ends the definition of function v
* sun run (v) - calls the function v
* quantum [if condition is true/false then] - starts a loop
* quantum end - ends a loop
* blackhole a(+/-)1 - adds or subtracts 1 to/from variable a
* higgsfield - clears the screen
* comment - starts a comment
* :: - ends a comment
* vacuum - makes the program get stuck in an infinite loop
* bigfreeze - ends the entire program
== Implementation ==
InSpace compiler that I built for my senior project: https://github.com/tobes898/SeniorProject17 (Linux Only) Relios898 (talk) 19:54, 25 February 2018 (UTC)Relios898: 
Category:Languages
Category:2017
Category:Unimplemented
In Your JSON

Category:2023
Category:Implemented
Category:Brainfuck equivalents
Category:Languages
In Your JSON is an esoteric method of writing Brainfuck created by Blair Myhre in 2023. As the name might suggest, code is written in a JSON file, then transpiled and executed. Each individual action (e.g. +) is written as a value in a unique key, like so: "Action1": "+" Keys MUST be unique and follow the formula of ActionX. Therefore, a program may look like this:
 {
 "Action1": ",",
 "Action2": "[",
 "Action3": ".",
 "Action4": ",",
 "Action5": "]"
 }
= NodeJS Translator =
Use in tandem with a Brainfuck JavaScript interpreter:
 function iyj(file) {
 let x = ""
 for (let i = 0; i < Object.keys(file).length; i++) {
 x += file[`Action${i + 1}`]
 }
 return x
 }
Note that this code will end with an error if a key is not named ActionX as described above. This is the most basic way to write it.
= Python Translator =
Use in tandem with a Brainfuck Python interpreter:
 iyj=lambda c:"".join(__import__("json").loads(c)[f"Action{i+1}"] for i in range(len(list(__import__("json").loads(c).keys()))))
Note that this code will end with an error if a key is not named ActionX as described above. This is the most basic way to write it.
Inc

Inc is a joke language invented by User:A that can only add the top of the stack.
== Instructions ==
There is initially a 0 in the stack.
* any character This increments the top of the stack.
== Implementation ==
print(len(""#Insert program here
))
Category:Languages
Category:2019
Category:Implemented
Category:Joke languages
Category:Total
Category:Unusable for programming
Category:Stack-based
IncCa

IncCa (Increment and jump if Carry)- is an OISC by User:ChuckEsoteric08 that is easy to implement
==Specification==
IncCa runs on Self-Modifying Virtual Machine with width of an address and a IP (which are equal) being 8, 16, 32 or 64 and one instruction
 a b
Meaning "Increment address a and if it overflows jump to address b". Program halts if IP overflows
Category:Languages Category:OISC Category:Bounded-storage machine Category:Unimplemented Category:Self-modifying
IncLoop

IncLoop in a programming language designed to have short programs that might never halt if you run it on a real computer though theoretically an infinite loop is impossible
== Specification ==
IncLoop has a counter that starts at 0 and two commands:
* . increases the counter by 1
* (...) repeats whatever is inside for the amount of times equal to the value of counter when the loop was entered
== Practically infinite loops ==
The idea is that the program runs for so long that no one can wait until it finishes.
One way is ..(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((()))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))). However, there are much shorter variants.
The shortest variant is ...(((.)))
To estimate its time, let's measure it by the final value of the counter, which is how many times a . was executed.
* . increases it by 1
* (.) doubles it
* ((.)) multiplies it by 2 to the power of it
If it is at least 2 and we perform ((.)) at least thrice, it will become at least 8 after first time, at least 2048 after the second time, and at least 2**2059 finally, which is much more than the first way runs. We can do that with ..((.))((.))((.)), ...(((.))), or ..((((.)))).
==External resources==
* An interpreter written in JavaScript
Category:Languages Category:Total Category:No IO Category:Unusable for programming Category:Implemented Category:2021
Inca

Inca is a language based on APL mapped to the ASCII character set. 
The name "inca" refers to the data-storage device the quipu
and its similarity to array-structured data.
Inca exists in two distinct versions: the original inca.c implementation which is limited to integer data, and the newer inca2.c implementation which has homogeneous arrays of integer, character, or double type. Different syntax and symbol choices have led to the result that the two versions are not compatible.
This page will describe inca2 as the more interesting of the two.
Monadic functions: ! not, # shape, * sign of, + identity, , ravel, - negate, ; execute, < box, > unbox, @ reverse, [ floor, ] ceiling, _ file, ` transpose, { size, | absolute value, ~ iota.
Dyadic functions: ! not equal, # reshape, $ or, % divide, & and, * times, + plus, , cat, - minus, . logarithm, / compress, < less than, = equal, > greater than, @ rotate, [ minimum, \ expand, ] maximum, ^ power, _ file, ` transpose, { from, | modulus, ~ find. 
Monadic operators which produce a monadic derived function: f/ reduce using f, f\ scan using f, f_ apply f along first axis, f! not f, and the unusual operator @ figurative transpose. .@ identity transpose, -@ horizontal transpose, |@ vertical transpose, \@ y=x transpose, /@ y=-x transpose, +@ horz + vert transpose, >@ horz + y=x transpose, <@ horz + y=-x transpose.
Monadic operators which produce a dyadic derived function: 'f* power using f, f! not f, f. jot-dot function table, and the unusual = operator. == is the same as = , != is the same as ! , <= less than or equal, >=` greater than or equal.
Dyadic operators which produce a dyadic derived function: f&g f of g f(g(x,y)), f.g f/ (x)g(y) for rows of x (or first axis) and columns of y (or last axis).
==External resources==
Project page.
Category:2014
Category:Functional paradigm
Category:Multi-dimensional languages
Category:Implemented
Category:APL-like
Category:Languages
Incdecisive Machine

Incdecisive Machine is a Minsky Machine variation designed by Keymaker in 2022.
==Program and execution==
The program consists of 0 or more instructions. Execution begins in the first instruction and halts (successfully) if the very last instruction goes to 'the next instruction' (which does not exist in that case). The two instructions are:
:x inc A n : Increase register A by one. If A was 0 before it was increased, go to the next instruction. If A was non-zero before it was increased, go to the instruction n.
:y dec A : Decrease A by one if its value is larger than 0. Then continue to the next instruction whether the register was decreased or stayed 0.
==Computational class==
The language is Turing-complete. It was designed with the 2-register Turing-completeness in mind, and there exists a translator that can translate any Minsky Machine program with any number of registers into 2-register Incdecisive Machine. There also exists a simple translation that uses x+1 registers, where x is the amount of them in the Minsky Machine program. See the external link.
There is also a simple method for translating n-register Minsky Machine into n-register Incdecisive Machine, made by ais523, found here.
==External resources==
* Incdecisive Machine page (detailed explanations of the language and the translations, translator program, interpreter in Python)
Category: Turing complete
Category: Turing tarpits
Category: Low-level 
Category: Languages
Category: No IO
Category: Implemented 
Category: 2022
Increment

== Commands ==
Character 	What it does
Any character except the ones listed below	Increment the accumulator by the character's ASCII value.
& 	Print the accumulator, and end the program.
[ 	Turn off the user's computer.
== Examples ==
=== Discover the answer to life, the universe, and everything ===
*&
=== Shut down the user's computer ===
 [
== Partial Implementation ==
=== Lua Implementation ===
function Increment(str)
	local acc = 0
	for char in str:gmatch(".") do
		if char == "&" then
			print(acc)
			return
		elseif char == "[" then
			--Works in Microsoft Windows
			os.execute("shutdown -s -f")
			return
		else
			acc = acc + string.byte(char)
		end
	end
end
For UNIX-like operating systems:
function Increment(str)
	local acc = 0
	for char in str:gmatch(".") do
		if char == "&" then
			print(acc)
			return
		elseif char == "[" then
			--Works in UNIX-like operating systems 
			os.execute("poweroff")
			return
		else
			acc = acc + string.byte(char)
		end
	end
end
=== Python Implementation ===
import os
code=input()
x=0
for i in code:
 if '&[' not in i:
 x+=ord(i)
 if i=='&':
 print(x)
 if i=='[':
 os.system('shutdown -p -f')
Category:Languages
Category:Joke languages
Category:Total
Category:2019
Category:Output only
Category:Unusable for programming
Incrementing machine

Incrementing machine is a variation of Minsky machine discovered by User:ChuckEsoteric08. Unlike any other counter machines it can only increment registers, but not decrementing or setting them to 0. It was discovered while author was working on Turing-completness proof for AddJump
==Specification==
Incrementing machine uses unbounded amount of registers as memory which are numerated with the first register being 0, second being 1 and so on. All of them are initially set to 0. Commands look like this:
 <label> <counter1> <counter2> <branch>
It is executed as follows: increment register <counter1> and if result is equal to <counter2> then jump to label <branch>
==Computational class==
Incrementing machine is Turing-complete since it can implement Counter machine with following instructions:
 INC x y - Increment counter x and jump to line y
 DEC x y - Decrement counter x and if result was 0 jump to line y
If a command has only one argument, it means that it would jump to the next command
Which can simulate Minsky machine JZDEC x y insturction like that:
 INC x
 DEC x y
 DEC x
Each counter is represented as two Incrementing machine counters, called a and b. INC insturction is simulated like that:
 <line number> a a y
DEC instruction is simulated like that:
 <line number> b a y
Where y is the line to which it should jump to. It will also prove that it needs only 4 counters to be Turing complete
==Implementations==
The following Python script is an interpreter.
prgm = [[]]
prgm.pop(0)
while True:
 line = input('%s ' % len(prgm)) # Generates labels automatically
 if line != "eof":
 line = list(line.split(" "))
 prgm.append([int(line[0]), int(line[1]), int(line[2])])
 else: break
tape = [0]
for i in range(0, 256): # Expansion is trivial
 tape.append(0)
# Executes the program
def incmac(label, counter1, counter2, branch):
 global tape
 global inst
 tape[counter1] += 1
 if tape[counter1] == tape[counter2]:
 inst = branch
 else: inst += 1
 print(tape[counter1], end=" ") # For debugging
inst = 0
while inst < len(prgm):
 incmac(inst, prgm[inst][0], prgm[inst][1], prgm[inst][2])
256-cell implementation, but it can be expanded.
Category:Languages Category:Turing complete Category:Turing tarpits Category:OISC Category:Implemented Category:Computational models
IndentationError: unexpected indent

IndentationError: unexpected indent is an esolang created by User:None1 and inspired by SyntaxError: invalid syntax which is inspired by foo : The term 'foo' is not recognized as the name of a cmdlet, function, script file, or operable program. Check the spelling of the name, or if a path was included, verify that the path is correct and try again. which is inspired by bash: foo: No such file or directory. It imitates yet another Python error which is common for beginners - Indentation error.
==Command==
Every command is valid, and prints:
 File "<stdin>", line 1
 [command]
IndentationError: unexpected indent
==Interpreter==
===Python===
 print('\n'.join([f' File "<stdin>", line 1\n {i}\n\nIndentationError: unexpected indent' for i in __import__('sys').stdin.read().split('\n')]))
===C===
The program implements a REPL, and uses the insecure function gets to read the program.
#include<stdio.h>
char _[1000000];int main(){while(!feof(stdin)){printf(">>> ");gets(_);printf(" File \"<stdin>\", line 1\n %s\n\nIndentationError: unexpected indent\n",_);}}
===Batch===
@echo off
:bad
set /p x=^>^>^> 
echo File "<stdin>", line 1
echo %x%
echo.
echo IndentationError: unexpected indent
goto bad
==See also==
* SyntaxError: invalid syntax
* NameError
Category:Languages
Category:Joke languages
Category:Unusable for programming
Category:Output only
Category:Total
Category:2024
Category:Implemented
Indirect

Indirect is a brainfuck derivative inspired by other brainfuck derivatives designed by User:Quojil in 2014. It extends a lot of functionality also. It's primary inspiration is Minifuck, as it is a very small version of brainfuck, but does not have much functionality. Like Minifuck, Indirect has only three instructions, but can do a lot more.
==How is it different==
Indirect's name is inspired by how all the operations you can do, a total of 15, can be managed with only three instructions.
In order to achieve this, Indirect has two parts of memory, the "instruction bay" and the "data memory". Using three instructions, you can increment and decrement the value in the instruction bay. After you use the "!" instruction, it will execute the operation the number in the instruction bay references.
For example:
 +!! increment current cell by two
 ++++++++++++! sleep for two second seconds
 +! terminate
The first line sets the instruction bay to 1 and then executes it twice to set the current cell to two.
Next, the instruction bay gets incremented to 13 and then executed to sleep. It sleeps for two seconds because the current cell is two.
And finally, the instruction bay is set to 14 and executed to terminate the program.
==Instructions==
==="instruction bay"===
Command	Description
+ 	Increment number in the instruction memory
- 	Decrement the data in the instruction memory
! 	Run operation
==="operations"===
(the things that are ran from the instruction bay)
(these operations ONLY use the number memory)
(whenever the word "byte" is used, it means the current byte. "byte+1" means the byte one cell right)
Operation	Description
0 	move cell pointer left
1 	increment current cell
2 	decrement current cell
3 	zero out current cell
4 	input if current cell equals zero, else output
5 	open/close file
6 	skip next instruction in the program if current cell equals zero
7 	AND byte and byte+1
8 	NAND byte and byte+1
9 	OR byte and byte+1
10 	NOR byte and byte+1
11 	XOR byte and byte+1
12 	NOT byte
13 	sleep for time (in seconds) designated by current cell
14 	stop the program
15 	nop
Note:
The open/close file operation has a funky functionality. When you call it, a file in the directory the interpreter is being ran in will be created with the name "i/o". After opening the file, the 4th operation (input/output) will add the letter the current cell holds to the end of the file if it outputs, and when input is called it will load the last byte in the file. After calling open/close again, it will close i/o and the input/output operation will return to normal.
==Specifications==
The size of the instruction bay is one nibble, and the number memory has 8 one-byte cells.
==Examples==
===Cat program===
A one-time cat program is implemented in the following:
 ++++!!
==Interpreter==
* Common Lisp implementation of the Indirect programming language.
Category:Languages
Category:Brainfuck_derivatives
Category:Cell-based
Category:Low-level
Category:2014
Category:Implemented