nyuuzyou/wikis huggingface dataset:
7Basic

7Basic is an ambitious project aimed at creating a cross-platform BASIC compiler that generates native Win32 and i386 ELF executables.
==Compiler==
The compiler takes 7Basic source files as input and generates an x86 assembly file that must then be assembled and linked. The resultant binary file depends on libc for I/O.
==Syntax==
The syntax of the language is very loosely based on VisualBasic.
* variables are declared with their type
* values can be read from STDIN and printed to STDOUT
* basic conditional expressions and loops are supported
==Example==
This simple example will print the classic "Hello, World!" greeting five times:
 DIM i AS INTEGER
 
 i = 0
 WHILE i < 5
 PRINT "Hello, World!"
 i = i + 1
 END WHILE
Category:Languages
Category:2015
Category:Implemented
7 bottles of tommyaweosme

7 bottles of tommyaweosme is a programming challenge designed to be like 99 bottles of beer on the wall but different.
This is one of the requirements to be aweosme-complete.
== Lyrics ==
 7 bottles of tommyaweosme on the wall
 7 bottles of tommyaweosme
 take one down
 get +100 health
 6 bottles of tommyaweosme on the wall
 6 bottles of tommyaweosme
 take one down
 get +100 health
 ...
 2 bottles of tommyaweosme
 take one down
 get +100 health
 one last bottle of tommyaweosme on the wall
 one final bottle of tommyaweosme
 walk away
 keep it up there
 let it ferment into greatness
Category:Program forms
==Examples==
===Scratch-like pseudocode===
===Python===
for i in range(7, 1, -1):
 print("%d bottles of tommyaweosme on the wall\n%d bottles of tommyaweosme\ntake one down\nget +100 health" % (i,i))
print("one last bottle of tommyaweosme on the wall\none final bottle of tommyaweosme\nwalk away\nkeep it up there\nlet it ferment into greatness")
The lines are too long to be displayed correctly.
7 bytes XD

7 bytes XD is an esolang made by User:DockedChutoy with the goal of creating the smallest interpreter.
== Instructions ==
Every program is valid. Sadly there is no output, making 7 bytes XD input only.
== Examples == 
=== APLWSI Interpreter ===
 # This program is an APLWSI interpreter.
 public static void integer function main with no arguments returns the smallest non-negative integer.
 // The end!
 raise IndexError("list index out of range")
=== Quine ===
It is technically impossible to make a quine due the mentioned inability of output.
== Interpreter ==
=== Python ===
This is the official interpreter.
 input()
=== ><> ===
 >i:01-=?;00.
=== brainfuck ===
 ,[,]
=== ; ===
 ;
=== Inputfish and How to learn this language ===
 i
=== Empty ===
 I
=== ? ===
 ?-
=== +++ ===
 ?$
=== Dreadfish ===
 u
=== 15 and 35 ===
 @
=== Txet ===
 i7
=== C++ ===
 #include <iostream>
 int main(){char[1] a; std::cin>>a; return 0;}
=== 1+ ===
 ,
=== LogicF--- ===
 ,
==See also==
* 9 bytes :I, the exactly same thing.
Category:Languages
Category:Total
Category:Implemented
Category:No IO
Category:Unusable for programming
Category:Zero-dimensional
Category:Joke languages
Category:2022
8

8 is an esoteric programming language made by User:AmNow.
== Commands ==
8 runs in an infinite loop, until it hits the 0 command. (see below)
 1:[x]: = Print X. Replace the colons with semicolons if you don’t want a newline.
 2:[x]<[y]: = Set X to the value of Y.
 3:[x]: = Gets variable X’s value.
 4:[x]: = Input Into Variable X.
 5:[x];(y): = While X is true, Do Y.
 6:[x]’[op]’[y]: = Do X OP Y and store the result in X. Replace the apostrophes with commas to return the value and not store in a variable 
 7:[x]§(y): = Like 5, but do it once.
 0:: = Halt Execution.
== Programs ==
=== Hello, World! ===
 1:[“Hello, World!”]:
 0::
=== Truth Machine ===
 4:[inp]:
 1;[3:[inp]:];
 5:[6:[3:[inp]:],[==],[1]:];(
 1;[1];
 ):
 0::
===Cat Program===
An infinitely repeating cat program, which terminates on an empty input, is demonstrated:
 4:[input]:
 5:[6:[3:[input]:],[!=],[“”]:];
 (
 1:[3:[input]:]:
 4:[input]:
 ):
 0::
===Counter in Range===
This program queries the user for a counter's start and end values, the former of which must be less than or equal to the latter, and prints all integer numbers in the contained closed range.
 1:[“Please input the counter start value: ”]:
 4:[counterStart]:
 
 1:[“Please input the counter end value: ”]:
 4:[counterEnd]:
 
 2:[counter]<[3:[counterStart]:]:
 
 5:[6:[3:[counter]:],[<=],[3:[counterEnd]:]:];
 (
 1:[3:[counter]:]:
 6:[counter]’[+]’[1]:
 ):
 0::
== Computational Class ==
8 is (obviously) Turing Complete.
==Interpreter==
* Common Lisp implementation of the 8 programming language. Please note that the concrete character set deployed constitutes a dependency on the Common Lisp implementation; in corollary, Unicode support may or may not be a feature incorporated in the personal environment. The interpreter at hand has been developed and tested with Steel Bank Common Lisp (SBCL) version 1.1.4 as part of the Lisp Cabinet 0.3.5 bundle.
Category:Turing completeCategory:2021Category:LanguagesCategory:Implemented
8-Bit

8-Bit is an esolang created by User:Infinitehexagon in hopes of making his first Turing tarpit using Binary numbers, but it is Turing-incomplete due to the fact that the cells are bounded and are limited to 8 cells. Language also lacks any control flow and is Total. This language was originally Infinite Hexagon's REAL first esolang made last year and scrapped.
Category:LanguagesCategory:2023Category:TotalCategory:Unusable for programmingCategory:Implemented
==Commands==
Command	Description
f 	flip the bit in the cell. eg 1->0 and vice-versa.
v 	Outputs current bit
> 	Shift the memory pointer by 1 to the left(0) or the right(1). Default is right(1).
: 	flip the direction of the memory pointer. eg 0->1 and vice-versa.
i 	get input of a bit and store it into the current cell
! 	NO-OP
==Programs==
===Hello World===
vfvfvvfvfvvv!vfvvfvvfvfvfv!fvfvvfvfvvfvv!vfvvfvfvvfvv!vfvvfvfvvvv!fvvfvfvfvvfvv!vvfvfvvvvv!vfvfvfvfvfvvvv!
fvfvvfvfvvvv!fvfvvvfvvfvfv!vfvvfvfvvfvv!vfvvfvvfvfvv!vvfvfvvvvfv
The text would be 01001000011001010110110001101100011011110010110000100000010101110110111101110010011011000110010000100001 before converted to ascii and Hello, World! after. Because there is only 8 cells, only cell 0 is used and toggled between 0 and 1 and the text is all the results of flipping cell 0.
=== Shift left ===
i>i>i>i:v>>>:>v>v
from 1234 to 4123.
=== Shift right ===
i>i>i>i:>>v:>v>v:>>>v
from 1234 to 2341.
===One Time Cat===
iviviviviviviviv
==Extended version by User:ChuckEsoteric08==
It adds these commands:
Command	Description
(...) 	Execute if 0
{...} 	Execute if 1
[...] 	While 0
< 	Set pointer to the first cell
All of them can be nested. It also converts input from ASCII to binary and output into ASCII after program ends.
== Implementation ==
*Scratch
(Slightly inaccurate interpreter regarding to Scratch's functions)
8 bits, 256 bytes

8 bits, 256 bytes is an esolang by User:ChuckEsoteric08 inspired by Chip-8.
==Description==
It has 8-bit Program Counter, allowing programs to have 256 bytes at most, it has 16 8-bit internal registers, R0-RF, last one used only as a flag for other instructions, and a 8-bit Stack Pointer for the call stack. Program uses the same store for both program and data. There is also a 64x64 screen and a 16-key keyboard similar to Chip-8. Sprites are encoded as a series of 1 to 16 bytes similar to Chip-8.
===Commands===
Each command is dtored as 2 bytes, so each program can store only 128 commands. For the following commands it uses this values:
 n, x or y - nybble, a single hex value
 b - a single byte
It has following commands, written in hex:
Hex 	Assembly 	Description
0000	CLS 	Clears the screen
0001	RET 	Returns from subroutine
01b 	CALL b 	Call subroutine at address b
02b 	JMP b 	Jumps to instruction b
1nb 	SE n, b 	Skips next instructuon if Rn = b
2nb 	SN n, b 	Skips next instruction if Rn != b
03xy	EQ x, y 	Skips next instruction if Rx = Ry
04xy	NE x, y 	Skips instruction if Rx != Ry
4nb 	SB n, b 	Sets Rn to b
5nb 	LD n, b 	Loads a value from address b to Rn
6nb 	ST n, b 	Stores a value of Rn to address b
05xy	SR x, y 	Sets Rn = Ry
7nb 	ADD n, b 	Set Rn += b
8nb 	SUB n, b 	Set Rn -= b
06xy	ADR x, y 	Set Rx += Ry
07xy	SUR x, y 	Set Rx -= Ry
08xy	AND x, y 	Set Rx = Rx AND Ry
09xy	OR x, y 	Set Rx = Rx OR Ry
0Axy	XOR x, y 	Set Rx = Rx XOR Ry
0B0n	RS n 	If least significant bit is 1, Set RF to 1, else set it to 0. Then divide Rn by 2
0B1n	LS n 	If most significant bit is 1, Set RF to 1, else set it to 0. Then multiply Rn by 2
0B2n	SP n 	Skip next command if key n is pressed
0B2n	NP n 	Skip next command if key n is pressed
0B3n	SK n 	Wait for key press, and set Rn to the value of pressed key
9xyn	DR x, y, n	Draw n-byte sprite at coordinates Rx, Ry
Each time after addition or subtraction wraps around RF is set to 1, if after an operation was performed it didn't wrap RF is set to 0
Category:Languages Category:Unimplemented Category:2024 Category:Low-level Category:Finite state automata
8ial

8ial (or 8 instruction assembly language) is basically self explanatory. It's an 8 instruction assembly language created by User:Ractangle.
==Commands==
Command	Action
EVR 	Edit the Value of the currently pointing Registry
PSH 	PuSH a registry
;A 	creates label A
OUT 	OUTput the top of the stack
PTR 	Point To Registry
PUT 	inPUT into registry
JIR 	Jump to a label If Registry is equal to a number
!A 	comments A
To halt a program. you need to reach the EOF.
==Syntax==
An Extended Backus-Naur Form (ENBF) formulation of the syntax shall be adduced:
 program := { innerLine } , [ finalLine ] ;
 innerLine := [ command ] , [ comment ] , newlines ;
 finalLine := [ command ] , [ comment ] ;
 comment := "!" , { character - newline } ;
 command := evrCommand | jirCommand | labelDefinition | outCommand | ptrCommand | pshCommand | putCommand ;
 evrCommand := "EVR" , numericOperand ;
 jirCommand := "JIR" , labelName , registry , numericOperand ;
 labelDefinition := ";" , labelName ;
 outCommand := "OUT" ;
 ptrCommand := "PTR" , registryName ;
 pshCommand := "PSH" , registryName ;
 putCommand := "PUT" , registryName ;
 labelName := labelCharacter , { labelCharacter } ;
 labelCharacter := digit | letter | "-" | "_" ;
 numericOperand := signedInteger | registryName ;
 registryName := "$" , unsignedInteger ;
 signedInteger := [ "+" | "-" ] , unsignedInteger ;
 unsignedInteger := digit , { digit } ;
 digit := "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" ;
 letter := "a" | ... | "z" | "A" | ... | "Z" ;
 newlines := newline , { newline } ;
 newline := "\n" ;
 space := " " | "\t" ;
==Examples==
===Truth-machine===
 PUT $1
 JIR o $1 1
 PSH $1
 OUT
 JIR e $1 0
 ;o
 PSH $1
 OUT
 JIR o $1 1
 ;e
Try it in the online Common Lisp interpriter
===Cat program===
A perpetual numeric cat program shall be produced below:
 ;repeat
 PUT $1
 PSH $1
 OUT
 JIR repeat $1 0
Try it in the online Common Lisp interpreter
==Interpreter==
* Common Lisp implementation of the 8ial programming language.
Category:Languages Category:Low-level Category:Stack-based Category:Implemented Category:2024
91v

91v is an esoteric programming language created by User:Zero player rodent. It only has 9 memory cells that can be accessed. It has a large amount of commands, but the language is much less powerful than some other, more minimalistic languages, mostly because of the memory limitations. Although there are only 9 memory cells to be used, each cell can store infinitely large numbers.
== Commands ==
Command	Outcome
1 	Pointer jumps to cell 1, and adds 1 to pointer's memory.
2 	Pointer jumps to cell 2, and adds 2 to pointer's memory.
3 	Pointer jumps to cell 3, and adds 3 to pointer's memory.
4 	Pointer jumps to cell 4, and adds 4 to pointer's memory.
5 	Pointer jumps to cell 5, and adds 5 to pointer's memory.
6 	Pointer jumps to cell 6, and adds 6 to pointer's memory.
7 	Pointer jumps to cell 7, and adds 7 to pointer's memory.
8 	Pointer jumps to cell 8, and adds 8 to pointer's memory.
9 	Pointer jumps to cell 9, and adds 9 to pointer's memory.
? 	Pointer jumps to a random cell.
v 	Adds the number stored in the pointer's memory to cell the pointer is on.
" 	Prints the ASCII character associated with the number on the cell the pointer is on.
p 	Prints the pointer's memory as a number.
o 	Prints the value of the cell that the pointer is on.
{ 	Sets the value of the cell that the pointer is on to 0.
} 	Sets the pointer's memory to 0.
$ 	Gets a character from the input and stores it as an ASCII value in the cell the pointer is on.
; 	Goes past the next ":" if the value of the cell the pointer is on is equal to 0.
: 	Goes to last ";" if the value of the cell the pointer is on is higher than 0.
== Programs ==
2191919v}1vo9"};1vo9"}:
This program counts until the program is manually terminated.
91v"vv}41v}62vvv}2vvv}12v}2v}73vvv}43v}64vvv}14v}55vvv}25v}46vvv}6v}37vvv}7v}47}82vv}68}8vvvv}8vvv}8}8v}39vvvv}?"?"?"
This program is a small slot machine game. Keep trying until you match three characters.
== External resources ==
*Interpreter source code (Ruby)
Category:Languages
Category:Brainfuck derivatives
Category:Implemented
95-98

95-98 is a esolang thats just... stupid. it was made by User:Yayimhere
== name ==
the name comes from a wikipedia article where it said 95-98 somewhere. the name works as code an results in the list being equal to [6, 7]
== memory ==
memory is stored in an unbounded list starting a 1 as the only element. if a number is negative there must be a ` after it
== how it works ==
the command x-y will append all the numbers in range x to y, to the list(so for example 1-100 will add all the numbers from 1 to 100 excluding 1 and 100).
if x is more than y however it will delete the first element of the list.
if x and y are equal it will delete every non 0 number. if y is 0 and x is non 0 it will delete every number in the list thats not equal to x.
if x and y are both 0 it will do the following command if the first element of the list is not 0. 
if x is not a number and y is 0 it will output the whole list as unicode chars. 
if x is not a number it will add user input as a number to the list. 
if y is not a number it will take user input as an unicode string(EOF) and add it to the list. 
if x and y are not numbers it will add together the first two elements in the list.
and if, x and y are both equal, AND x and y are not numbers it will loop whats between it and the nearest copy until the list becomes empty
anything thats not a command will be ignored
=== tip ===
a simple way to add any number n is to do: (n-1)-(n+1)
== examples ==
hello, world!:
 103-105 100-102 107-109 107-109 110-112 43-45 31-33 118-120 110-112 113-115 107-109 99-101 32-34 A-0
Looping counter:
 A-A 41-43 A-0 A-A
== computational class ==
its turing complete since any Bitwise Cyclic Tag program can be translated into 95-98 like this:
 10 -> 0-0 1`-1
 11 -> 0-0 0-2
 0 -> 1-0
 the program must also be encased by A-A
so the program:
 10 11 11 0 11 10 0 11 10 11 0 with datastring 1
becomes:
 A-A 0-0 1`-1 0-0 0-2 0-0 0-2 1-0 0-0 0-2 0-0 1`-1 1-0 0-0 0-2 0-0 1`-1 0-0 0-2 1-0 A-A
and the Collatz sequence:
 10 11 10 10 10 11 0 11 10 10 0 11 10 10 11 10 10 11 10 10 0 0 0 0 
 ↕
 0-2 1`-1 1`-1 A-A 0-0 1`-1 0-0 0-2 10 0-0 1`-1 0-0 1`-1 0-0 0-2 1-0 0-0 0-2 0-0 1`-1 0-0 1`-1 1-0 11 0-0 1`-1 0-0 1`-1 0-0 0-2 0-0 1`-1 0-0 1`-1 0-0 0-2 0-0 1`-1 0-0 1`-1 1-0 1-0 1-0 1-0 A-A
note that the number of times 0-2 1`-1 1`-1(excluding the 0-2 in the first one) is the number of times 100 is added to the datastring
== external recourses ==
wikipedia page holding name
Category:Languages
Category:Turing complete
Category:Unimplemented
Category:Pattern-based
Category:Low-level
Category:2024
99 (Joke language)

The 99 programming language has no instructions, and any piece of text that isn't on a same line with a preceding '#' (comment character in this language) is a syntax error. Leading and trailing white space is allowed. A valid program will always produce the same output: the lyrics of the song 99 bottles of beer.
==See also==
* 99 bottles of beer
* HQ9+
==External resources==
* The 99 programming language page, featuring the specification, an interpreter, and two sample programs
Category:Languages
Category:Joke languages
Category:Unusable for programming
Category:Output only
Category:Implemented
Category:2004
Category:Total
Category:No-code esolang
;

; is a joke esolang by User:None1, it has input, but not output.
==Command==
There is only one command: ;, which reads one line of input.
==Examples==
===Read one line of input===
 ;
===9 bytes :I interpreter===
 ;
==Interpreter==
===Python===
 [i!=';'or input()for i in input()]
Category:Languages
Category:Joke languages
Category:Unusable for programming
Category:2023
Category:Implemented
Category:Total
Category:Input only
;;;

;;; is an esolang made by User:Yayimhere 
== memory ==
memory is stored in a infinite tape holding 8 bit numbers.
== syntax ==
these are the commands:
 Caption text
symbol	command
; 	if current cell is 0 go left on tape. else decrement it
: 	increment current cell and go right. however if this increments 256 go left and goto the line equal to the current cell
/ 	decrement current cell. if this decrements 0 however jump back to the start of the program
\ 	go left unless current cell is a prime number
Category:Languages Category:Cell-based Category:No IO Category:Unimplemented
=

==Commands==
=
if the thing being assigned is a place:
 assign place with value(dec)/place value.
if the thing being assigned is a value:
 if the place value assigned recently equals to the first decimal number, jump forward the number of the second decimal number commands. Else, continue running.
Place value doesn't have "+" or "-".
4=+123
+143=-12
if anything is assigned to cell 0, print the ASCII value.
==Examples==
===XKCD Random Number===
 0=+52
==Interpreter==
===Python===
tape={}
def read_tape(x):
 if x in tape:
 return tape[x]
 return 0
import sys
code=sys.stdin.read().split('\n')
ip=0
recent=0
while ip<len(code):
 try:
 lhs,rhs=code[ip].split('=')
 except:
 ip+=1
 else:
 if lhs.isdigit():
 if not int(lhs):
 if rhs.isdigit():
 sys.stdout.write(chr(read_tape(int(rhs))))
 else:
 sys.stdout.write(chr(int(rhs)))
 if rhs.isdigit():
 tape[int(lhs)]=read_tape(int(rhs))
 else:
 tape[int(lhs)]=int(rhs)
 recent=int(lhs)
 ip+=1
 else:
 if rhs.isdigit():
 val=read_tape(int(rhs))
 else:
 val=int(rhs)
 if val==read_tape(int(lhs)):
 ip+=val
 else:
 ip+=1
Category:Languages
Category:2018
Category:Implemented
Category:Output only
=,-&~

=,-&~ is an esolang made by User:AmNow. =,-&~ makes the code look like a lot of dashes.
== Commands ==
Command	Description
- 	Push 0.
= 	Add 1 to the top stack element.
≡ 	Add 10 to the top stack element.
~ 	Add 100 to the top stack element.
∽ 	Negate the top stack element.
∸ 	Move bottom most value up.
-- 	Move top most value down.
-= 	Pop.
-≡ 	Swap the top stack element with that immediately below it.
-~ 	Duplicate the top stack element.
-∽ 	If the top value of the stack is 0, jump past matching -∸.
-∸ 	If the top value of the stack is not 0, jump back to matching -∽.
=- 	Plus. Take two numbers, add them, and push the result unto the stack.
== 	Minus. Take two numbers, subtract them, and push the result unto the stack.
=≡ 	Multiply. Take two numbers, multiply them, and push the result unto the stack.
=~ 	Divide. Take two numbers, divide them, and push the result unto the stack.
=∽ 	Input as a number.
=∸ 	Input as a Unicode character and push its ID.
≡- 	Output the top stack element as a number and pop it.
≡= 	Output the top stack element as a Unicode character and pop it.
Each two commands must be separated by at least one space.
== Programs ==
=== Truth-machine ===
 =∽ -∽ -~ ≡- -∸ ≡-
=== Cat program ===
An infinitely repeating cat program is implemented in the following:
 =∸ -~ ≡= -∽ =∸ -~ ≡= -∸
=== Fibonacci sequence ===
The following program produces a Fibonacci sequence generator, permitting the user to specify how many members of the same shall be created:
 =∽ - -~ ≡- - ≡ ≡ ≡ = = ≡= - = -~ ≡- - ≡ ≡ ≡ = = ≡= -~ -- =- -~ ≡- - ≡ ≡ ≡ = = ≡= ∸ - = ∸ == -∽ -- -≡ -~ -- =- -~ ≡- - ≡ ≡ ≡ = = ≡= -- - = -≡ == -∸
== Computational Class ==
=,-&~ is Turing Complete, as it can simulate BF.
 BF =,-&~
 + =
 - ∽ = ∽
 < ∸
 > --
 . -~ ≡=
 , -= =∸
 [ -∽
 ] -∸
 
==Interpreter==
* Common Lisp implementation of the =,-&~ programming language. Please note that the concrete character set deployed constitutes a dependency on the Common Lisp implementation; in corollary, Unicode support may or may not be a feature incorporated in the personal environment. The interpreter at hand has been developed and tested with Steel Bank Common Lisp (SBCL) version 1.1.4 as part of the Lisp Cabinet 0.3.5 bundle.
Category:Turing completeCategory: 2021Category:LanguagesCategory: ImplementedCategory: Stack-based
?

? (Ask, None-Ask) is a NONE dialect created by Jaip that allows the user to input numbers and strings and calculate basic expressions.
==Name==
The name "?" or "Ask" refers to the command "?" ("Ask"), with which the user's input can be accessed in "?".
==Syntax==
The syntax is the same as in NONE, only that there are some additional commands.
? asks for an input, ! outputs an input value.
===Memory system===
? has a memory for two numbers and one string. A number input always alternately overwrites the memory for the two numbers. So if Number 1 (N1) was last overwritten, Number 2 (N2) will now be overwritten.
===Commands===
+ after ? or ! stands for a number, - stands for a string. !++ calls a numerical value, !+- a calculation.
? 	Description
?+ 	Asks for a number input
?- 	Asks for a string input
!+ 	Returns N1 and N2
!++ 	Returns N1
!++- 	Returns N2
!+- 	Returns N1 + N2
!+-+ 	Returns N1 - N2
!+-- 	Returns N1 * N2
!+-++	Returns N1 / N2
!- 	Returns the string
To output the ! values, type p after the command.
Example: !+--p
==Examples==
===Cat program===
?-!-p
===Calculator===
++++++^pc++p+x++pc++++++p+t----p-x++pc++pc+x+v++++++++++p-vp++++++p
m(++++)m(++++)m(++++)m(++++)m(++++)m(++++)m(++++)m(++++)m(++++)m(++++)m(++++)m(++++)m(++++)m(++++)m(++++)m(++++)m(++++)m(++++)m(++++)m(++++)m(++++)
+v^p+x--pc+x+v++++++++++pc+vp+x++++++p_c+v++p++++++p+x--p++pc+x+v++++++++++p_-v--p+v++++p-x++++pc++++pc+vp+x++++++ps(+v)?+
+v^p+x--pc+x+v++++++++++pc+vp+x++++++p_++pc+vp----p+x++++p--pc+v--p_+xp+v++++p-x++++pc++++pc+vp+x++++++ps(+v)?+
+t----^pc+vp+x+v--p++++p-x++pc+x+v++++++++++ps(+v)
!++p_m(++)_!++-p_m(+v)_!+-p
!++p_m(++++)_!++-p_m(+v)_!+-+p
!++p_m(++++++)_!++-p_m(+v)_!+--p
!++p_m(+v--)_!++-p_m(+v)_!+-++p
==Links==
**Source Code
Category:Languages Category:Implemented Category:Total
?!

?! is an esolang, invented by User:None1. It has only 2 commands, but it is still Turing complete.
==Commands==
Just like its name, ?! has only 2 commands, which are ? (question mark) and ! (exclamation mark).
Because it has only these two commands you can interleave it with brainfuck or oOo CODE.
==Execution==
===! command===
Every ! command is interpreted as one of the command in brainfuck, which is called the "current command", the current command is initially +.
===? command===
Switch current command to the command right after the current command in +-,.<>[], each time the ? command is executed, It changes how ?! interprets !. If the current command is ], It becomes +.
Note that in ?!, when the brainfuck ] command is executed, it changes back to [ if the condition to jump is satisfied.
==Example Programs==
===Cat Program===
 !??????!????!?!????!
====Explaination====
! Execute +
?????? Switch command to [
! Execute [
???? Switch command to ,
! Execute ,
? Switch command to .
! Execute .
???? Switch command to ]
! Execute ]
===Hello World===
!!!!!!!!??????!???????!???!!!!??????!???????!???!!?????!???!!!?????!???!!!?????!???!????!!!!?????!??????!??????!???!?????!???!
?????!????!????!!???!??????!??????!???!?????!?????!??????!??????!!??????!??!????!!!??!?????!!!!!!!???!!?????!!!???!??!!??????!
?!?????!??!?!???????!?????!!!???!??????!!!!!!??!??????!!!!!!!!??!??!!???!???!??!???!!???!
==See also==
* Brainfuck
* tinyBF
* Malbrain
* Twocoman
* F2
Category:Brainfuck derivatives
Category:Languages
Category:Turning tarpits
Category:Turing tarpits
Category:Turing complete
Category:Cell-based