nyuuzyou/wikis huggingface dataset:
!I!M!P!O!S!S!I!B!L!E!

!I!M!P!O!S!S!I!B!L!E! is an esolang made by User:Mario0Fan
It is designed to be a pain in the butt to use.
It has no loops, only 2 memory cells to use and the commands are different every time you execute a command.
==How it works==
!I!M!P!O!S!S!I!B!L!E! has 3 commands that can execute ABPLWNL commands
Command	Description
> 	Moves the command pointer right
< 	Moves the command pointer left
. 	Executes a command that the pointer is currently pointing to.
The command pointer looks at a list of commands. This list of commands is just a list of ABPLWNL commands without the skip command.
Command	Description
1 	Increments A by 1.
2 	Decrements A by 1 if its not 0
3 	Swaps A and B.
4 	If B is not 0, B is decremented by 1 and A is incremented by 1.
5 	Adds the value of B to A and sets B to 0.
6 	Prints the value of B
7 	Prints an unicode character corresponding to the unicode value of B
8 	Sets A to 0
9 	Sets B to an integer the user has typed in.
The commands that move the pointer are shifted right after any command.
example:
 Command list before a command:
 ><.
 Command list after a command:
 .><
This makes it really hard to code in this language.
 *im bad at explaining*
==Examples==
===A program that prints 1===
 ..<..<><
If the commands weren't shifted, the code would look like this:
 .>>.>>>.
===ASCII code to ASCII character===
This program gets input from the user (one number) and outputs an ASCII character corresponding to the ASCII code.
 >.<>.<>.><>>
If the commands weren't shifted, the code would look like this:
 >>>>>>>>.<<.
==Interpreter and other stuff==
interpreter in python (replit)
Category:2022 Category:Implemented Category:Total
!Romanian

!Romanian is a esolang made by Mihai Popa. It's taken from the pseudocode language in many Romanian code books, but altered slightly.
== Syntax ==
The syntax is slimiar to pseudocode.
Comments can be done just like in C:
// Example
/* Hello!
 * Hello!
*/
Or in pseudocode:
Comentariu Example
Bloc de text
 Hello!
 Hello!
== Commands ==
 Command list
!Romanian 	Meaning
Program [nume], [ieșire/intare], [ieșire/intare] 	Declares the start of the program, and input/output. Just like in Pascal. Can be omitted.
Repetă 	Do
Până când [expresie] 	While the condition is false
Cât timp [expresie] 	While the condition is true
Cât timp [expresie] execută 	While loop
Dacă [expresie] atunci 	If block
Altfel dacă [expresie] atunci 	Else if block
Altfel 	Else block
Citește [var] 	Gives user input to a variable
Scrie [var/expresie] 	Prints text or a value to the screen
[var] = [valoare] 	Sets the variable to a value
Pentru [var] <- [start],[sfârșit],[pas] 	For loop block
Început 	Begins the program. Can be omitted.
Sfârșit 	Ends the program. Can be omitted.
Întreg/Zecimal/Caracter/Șir/Zecimal-64/Listă/Vector	Declares the variables for later use. Equivalent to int, float, char, string, float64, list, array.
== Examples ==
=== Hello, world! ===
Program hello, ieșire
Început
 Scrie "Hello, world!"
Sfârșit
Or, if you want in Romanian:
Program bună, ieșire
Început
 Scrie "Bună, lume!"
Sfârșit
=== Cat ===
Program cat, intare, ieșire
Început
 Citește cat
 Scrie cat
Sfârșit
=== Truth Machine ===
Program truth, intare, ieșire
Început
 Citește truth
 Dacă truth = 0 atunci
 Scrie 0
 Cât timp truth = 1 execută
 Scrie 1
Sfârșit
Category:Languages
Category:2024
Category:Unimplemented
Category:High-level
Category:Pseudonatural
!Tautologos (Archived)

!Tautologos is an esoteric programming language by User:Rdococ derived from Tautologos and Table. It was intended to be the 'reverse' of Tautologos before it was confirmed to be uncomputable.
== Semantics ==
!Tautologos has three types. These are functions, tables and symbols. This is the intended 'reversal' from Tautologos, a language based on the lambda calculus with only functions. It's best you try not to think about it too hard, given that Tautologos itself was a reversal of Table.
A program is a set of declarations assigning symbols to values, whether they be functions, tables or other symbols. Symbols that have been assigned resolve to the assigned value, while symbols that have not resolve to themselves. Functions may have parameters, another way to assign symbols, and return values. Tables are mappings from values to other values, and table keys are resolved in the same way as values (i.e., if x is assigned, [x: y] maps the assigned value of x to y.)
At its core, !Tautologos is a variant of the lambda calculus with records. This makes it purely functional and highly object-oriented.
== Examples ==
true = {x, y: x};
false = {x, y: y};
zero = [Apply: {f, x: x}];
succ = {n: [Apply: {f, x: f(n[Apply](f, x))}]};
counter = [New: {value: [Increment: {n: counter[New](succ(n))}, Value: value]}];
Category:Languages
Category:Functional_paradigm
Category:Object-oriented_paradigm
Category:Turing_complete
Category:Unimplemented
Category:2016
!aBF'

!aBF' is the language whose name is pronounced "not a brainfuck derivative". The language uses 5 commands which manipulate a sole accumulator. The accumulator initially starts at zero. Additionally, new commands can be appended to the end of the program during execution, making loops possible.
==Commands==
Command	Name 	Description
! 	not 	Don't do the following command.
a 	AAAAAAAAAAAAAAA	Output the accumulator
B 	between 	Take everything between this B and the second-next B (or the end of the program), and replicate it to the end of the program a number of times equal to the value of the accumulator.
F 	five 	Add 5 to the accumulator.
' 	derivative 	Replace the value of the accumulator with its arithmetic derivative.
==Examples==
Output 420:
 FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFa
Truth-machine:
 ?'BaBB
Replace the ? with F for 1 or remove the ? for 0. As an example of this language's weirdness, the 1 case expands to a non-periodic pattern of a's and B's:
 F'BaBBaBBaaBBaaaaBBaaaaaaaaBB...
Truth-machine golfed:
 ?'BaB
==Implementations==
*Pyth implementation. Provide the !aBF' program as input. (Note: this implementation is improper, because numbers are not output in caps lock)
 K0W<ZlzJ@zZIqJ\!=hZ.?IqJ\aK.?IqJ\B=+z*j\B<c>zhZ\B2K.?IqJ\F=+K5.?IqJ\'=Ksm/KdPK)))))=hZ
*Python Interpretation. Provide program as input.
Category: Languages Category: 2020 Category: Implemented Category: Unknown computational class Category: Usability unknown Category: Output only Category: Self-modifying
!aoQ):

!aoQ>: (pronunciation: Not a golfing language) is meant to be a golfing language made by User:AmNow. !aoQ>: tries to take as many ideas from many different languages as possible.
== Commands ==
There is an implicit output at the end of every program. if there is nothing on the stack when the program ends, it will not print.
 Command What it does Origin
 L Push “Hello World” on stack HQ9+
 U Push “U” (I’m sorry). ALLSCII
 B Same as 9 in HQ9+ but push instead HQ9+
 [ Start Loop BF
 ] End Loop BF
 () Pushes string in () on the stack. Underload
 + Add
 - Subtract
 * Multiply
 / Divide
 % Modulus
 {} Pushes number in {} on the stack. Underload
 @ Pop and run the string as a program. Underload
 o Output top value on stack, popping it.
 i Input as a number.
 I Input as a string.
 ^ Move bottom value up 1+
 v Move bottom value down 1+
 ↺ Number to String ,,,
 ↻ String to number ,,,
 ⥀ Number to Unicode ,,,
 ⥁ Unicode to Number ,,,
 p Acts as p in ,,,. ,,,
 ! Negate 
 ? Equal Operator FALSE
 ¥ Pop
 $ Swap
 = Duplicate
 D ROT13 Encrypt
 O : in Stop but with the stack. Stop
 «» Infinite loop.
 ~ Logical Not
 F Push FizzBuzz(1 string)until top value. HQ9F+
 ⤽ Push the product of the entire stack. ,,,
 ⤼ Push the sum of the entire stack. ,,,
 b Push the Fibonacci # on stack.
 n Increment Top value on stack. HQ9+
 d n, but decrement. 
 u Interpret top value as Underload.
 \ Push 1 to top value on stack
 ± Push sign of top value.
== Programs ==
=== Fibonacci ===
 {1}«=bon»
=== Factorial ===
 «i\⤽o»
=== Truth Machine ===
 iO
=== FizzBuzz ===
 «iFo»
=== Quine ===
 U
Category:2021Category:LanguagesCategory: UnimplementedCategory:Stack-basedCategory:Golfing language
!brainfuck

==Summary==
!brainfuck (Pronounced "Macro Brainfuck") is a tape-based Brainfuck derivative
made by user Nick-1666 that closely follows brainfuck syntax. Except with macros!
==Syntax==
===Comments===
All valid Brainfuck is valid !Brainfuck and is interpreted as one would expect.
Due to macros having names that are also text, is that it is no longer possible to add
comments by writing pure text as you would in Brainfuck. This limitation was considered
and thus gave birth to line and multi-line comment syntax in !Brainfuck.
Here are examples of both:
## This is a line comment!
# This is a multi-line comment!
 This is a multi-line comment! #
Anything between a pair of hashes is a multi-line comment.
If a hash is immediately followed by another, the comment
becomes a multi-line comment from the second character 
until a newline.
==Macros==
===Macro Definitions===
A macro definition is composed as such !name ;
!0 [-];
The above example shows a macro definition. It assigns the name '0' to [-].
Valid macro names in !Brainfuck are strict to improve readability. It is conventional to
use lower camel-case (lowerCamelCase) although underscores are allowed for snake casing.
Macro names can only contain alphanumeric digits with the exception of underscores.
Note that the <name> and must always separated by a space or a newline.
!Add Two Cells
[
 ## subtract from the current cell and add to the next
 -<+>
 ## repeat until there is nothing else to decrement
];
The above code is valid and is an example of a useful addition macro.
===Macro Calls===
Now that we have defined macros, we can call them in code:
 +>+Add Two Cells!
# ^ ^ ^
 | | | We are left with the sum in the first cell
 | | Call the macro by adding a ! after the name
 | Set the first two cells equal to 1
#
==Future Improvements==
In order of importance:
=====Optimisation of interpreter=====
* remove useless pairs such as -+,
* stack commands and manipulate memory once (+++ -> +3)
=====Implement reassignment of macros=====
* ?x -; redefine x to be equal to -
* ?!x -; define or redefine x to be equal to -
=====Importing macros from macro files=====
* ![macros.mbf]; import all macros in macros.mbf
=====Transpiring to normal Brainfuck=====
* Replace all symbols with their definitions
* Replace all imported symbols with their definitions
=====Bootstrap Interpreter=====
Compiler
* x86_64
* wasm
===Turing Completeness proof===
Since Brainfuck is Turing Complete, and all Brainfuck is valid in !Brainfuck, it is of equivalent computational class.
==Implementations==
* Nick-1666's !Brainfuck interpreter made in rust (official)
Category:Works-in-Progress
Category:Brainfuck_derivatives
Category:Implemented
Category:Turing_complete
Category:Languages
Category:2022
!lyricly☭demote☭establish☭communism!

!lyricly☭demote☭establish☭communism! is a joke no-code esolang where
==Language specifications==
All characters are just ignored.
=="Examples"==
Well since this is actually a no-code esolang. Examples are useless here
==Implementations==
*GWBasic interpreter by User:Yes
*Batch interpreter by User:HungKhanh0106
*Shell interpreter by User:HungKhanh0106
* C# Interpreter > Console.ReadLine(); by User:SpaceByte
* C++ Interpreter > std::cin; by User:SpaceByte
* Python interpreter > by User:None1
* BASE Interpreter > by User:Ractangle
* brainfuck interpreter > by User:None1
* PowerShell interpreter > by User:None1
* Befunge interpreter > by User:PrySigneToFry
* APLWSI interpreter > by User:PrySigneToFry(And also THE SHORTEST INTERPRETER!!!!)
Category:2020
Category:Joke languages
Category:Implemented
Category:No-code esolang
!Мова

!Мова (or !Language in English) is an esolang based on !Romanian created by User:Ractangle.
==Syntax==
Command 	Action
Пачаць 	Starts program
Стоп 	End program
Скажы 	Prints The rest of the line next to it
Калі (...) інакш {...}	Conditional
(<name>,<value>) 	Creates a variable
Паўтор (...) {...} 	Loop command
Увод 	Input
Comments are made in the pythonic way, kinda
==Examples==
===Hello, world!===
 Пачаць main
 Скажы "Hello, world!" {пр}
 #пр means lf (linefeed)
 Стоп
===A+B Problem===
Since !Мова doesn't have interger conversion. We will have to make variable a and b
 (a,7) (b,3) (c,a+b)
 Пачаць main
 Скажы "A:" a {пр}
 Скажы "B:" b {пр}
 Скажы "Result:" c {пр}
 Стоп
===Truth-machine===
This esolang doesn't have conversion to interger command
 (i,Увод)
 Пачаць main
 Калі (i="0") інакш {Скажы 0;Стоп}
 Калі (i="1") інакш {Паўтор (1) {Скажы "1";}}
Category:PseudonaturalCategory:LanguagesCategory:2024Category:High-level
!한국어

!한국어 is designed by PSTF, and it is tottally and directly derivatived from ！中文 and ^English.
== Syntax ==
Programs must be written in Korean and must be strictly followed by their grammar.
== Examples ==
!한국어/Examples
== Categories ==
Category:Languages
Category:2023
Category:2024
Category:CJK
Category:Unimplemented
Category:High-level
Category:Pseudonatural
!한국어/Examples

Main page: !한국어
== Hello, world! ==
 줄 바꿈 없이 "전 세계 여러분 안녕하세요!" 를 화면에 인쇄합니다.
== G+N problem ==
 사용자 에서 두 개의 정수를 입력 한 다음 합계를 인쇄하십시오.
== Fizzbuzz ==
1 에서 1000 사이의 숫자를 인쇄합니다.모든 숫자 히우 에는 다음이 있습니다.
히우 모드 3=0이면 "Fizz" 를 인쇄합니다.
히우 모드 5 = 0이면 "Buzz" 를 인쇄합니다.
그러나 히우 가 3 과 5 의 배수(즉, 히우 나누기 15 = 0)이면 "FizzBuzz"가 인쇄됩니다.
그렇지 않으면 히우 값을 인쇄합니다.
== Quine ==
Code: 
 이 프로그램의 소스 코드를 인쇄합니다.
Output: 
 이 프로그램의 소스 코드를 인쇄합니다.
== Bubble Sort ==
--- 버블 정렬 ---
각 목록 요소를 두 개씩 비교합니다. 
전자가 두 요소 중 후자보다 크면 두 요소는 스왑됩니다. 
거품이 하나씩 떠오르듯이 더 큰 숫자가 목록의 끝으로 이동합니다.
---끝---
목록을 정의하고 사용자로부터 목록을 읽습니다.
버블은 전체 목록을 정렬하고 결과를 출력합니다.
== 아니. interpreter ==
 사용자 의 문자열을 입력하여 휴지통에 버린 다음 줄 바꿈없이 "아니." 를 출력합니다.
== Befunge93 interpreter ==
사용자 에서 문자열을 입력하고 SRC에 할당합니다.
SRC의 각 문자에는 다음이 있습니다.
> → 포인터를 오른쪽으로 이동합니다.
< → 포인터를 왼쪽으로 이동합니다.
^ → 포인터를 위로 이동합니다.
v → 포인터를 아래로 이동합니다.
? → 포인터를 임의로 움직입니다.
_ → 값을 팝합니다. 값=0이면 방향을 오른쪽으로 설정하고, 그렇지 않으면 왼쪽으로 설정합니다.
| → 값을 팝합니다. 값=0이면 방향을 아래쪽으로 설정하고, 그렇지 않으면 위쪽으로 설정합니다.
" → 다음 따옴표까지 이 방향으로 모든 문자를 읽습니다.
: → 스택에서 맨 위 요소를 복사하여 스택에 던집니다.
\ → 스택의 두 상단 요소를 바꿉니다.
$ → 스택에서 맨 위 요소를 팝 한 다음 휴지통에 버리십시오.
+ → 기혁 와 니은 를 팝한 다음 기혁 + 니은 를 누릅니다.
- → 기혁 와 니은 를 팝한 다음 니은 - 기혁 를 누릅니다.
* → 기혁 와 니은 를 팝 한 다음 기혁 × 니은 를 누릅니다.
/ → 기혁 와 니은 를 팝 한 다음 니은 ÷ 기혁 를 누릅니다. 부분적으로, a가 0이면 오류를 발생시킵니다 : "도대체 나에게 뭘 시켰어?!"
% → 기혁 와 니은 를 팝 한 다음 모듈로(니은 , 기혁)를 누릅니다.
! → 팝 기혁 , 기혁 = 0 이면 1을 누르고, 그렇지 않으면 0을 누릅니다.
' → 기혁 와 니은 를 팝하고 니은>기혁 이면 1을 누르고, 그렇지 않으면 0을 누릅니다.
. → 팝 기혁 를 입력하고 기혁 를 정수로 출력합니다.
, → 팝 기혁 를 하고 기혁 를 유니코드 문자로 출력합니다.
& → 사용자로부터 정수를 입력하고 스택에 푸시합니다.
~ → 사용자로부터 유니 코드 문자를 입력하고 유니 코드를 스택에 푸시합니다. (예를 들어, 느낌표는 33을 푸시합니다.)
0123456789 → 값을 스택에 푸시합니다.
# 또는 공백 표시 → 자리 표시자입니다.
@ → 프로그램을 종료합니다.
p → "놓다" 호출(나중에 사용하기 위해 값을 저장하는 방법). 세 개의 값 예시엔, 판시오스 및 쌍리슬 를 팝 한 다음 프로그램의 (판시오스, 예시엔) 위치에있는 문자를 ASCII 값 쌍리슬 가있는 문자로 변경합니다.
g → "가져오기" 호출(저장소에서 데이터를 검색하는 방법). 두 개의 값 예시엔 와 판시오스 를 팝 한 다음 프로그램의 해당 위치에서 문자의 ASCII 값을 푸시합니다. (x,y)가 범위를 벗어나면 0을 누릅니다.
== Categories ==
Category:Examples
$

$ is a "sister"-language to `, which works the same way, except how it has no negative numbers.
==Differences from `==
In $ cells can't have a negative value anymore.
For example:
 1$-1
Is invalid. Also, now instead of ` symbol $ is used.
Because there is no negative numbers, positives are used to jump backward, and jumping forward is impossible.
 1$+1
 +1$+1
in $ is equivalent to
 1`+1
 +1`-1
in `.
==Examples==
===Hello, World!===
This program prints “Hello, World!”:
 0$+72
 0$+101
 0$+108
 0$+108
 0$+111
 0$+44
 0$+32
 0$+87
 0$+111
 0$+114
 0$+108
 0$+100
 0$+33
===Cat===
This infinitely repeating cat program, translated from `, expects the user input's commorancy in the cell at the address one (1):
 This program relies upon the cell at the address one to contain the user input.
 0$1
 2$+0
 +0$+2
==Interpreter==
* Common Lisp implementation of the $ programming language.
Category:Cell-based
Category:Output only
Category:Finite state automata
Category:Languages
Category:Implemented
Category:2018
$!

$! is a minimalist esoteric programming language created by User:TheCanon2.
==Commands==
$! has a single 8-bit cell, xxxxxxxx. $! has 2 commands.
Command	Action
$ 	Shift 1 bit to the left
! 	Flip the rightmost bit.
The accumulator is printed as a number at the end of each line.
==Examples==
===Hello, World!===
!$$$!$$$
$!$!$$$!$$!
$!$$!$!$$
!$!$!$!
$$$!$$!$!$$
$!$$$$$
!$$!$$!$!$!
!$!$!$!$!
!$$!$
!$$!$!$$
$!$$
$$$!
This prints the ASCII values of the characters in 'Hello, World!' since $! has no character output.
===XKCD Random Number===
!$$
==Implementations==
The following Python script is an interpreter.
data = 0
code = [""]
while code[len(code)-1] != "eof":
 code.append(input('> '))
code.pop(0)
code.pop()
code.append("")
code = '\n'.join(code)
for inst in range(0, len(code)):
 if code[inst] == "$":
 data *= 2
 elif code[inst] == "!":
 if data % 2 == 1:
 data -= 1
 else: data += 1
 elif code[inst] == "\n":
 print(data)
 data = data % 256
This interpreter uses the symbol eof to mark the end of the program.
Category:Languages
Category:Accumulator-based
Category:Implemented
Category:Output only
Category:Total
Category:Low-level
Category:Unusable for programming
Category:2024
$3COND

$3COND is an esolang by User:BoundedBeans in which the only loop is based on real life time.
==Instructions==
 [(n)(code)(n)] - run the following code for n milliseconds
 ? - wait (top of stack) milliseconds
 _ - push 0 to the stack
 + - increment the top value of the stack
 - - decrement the top value of the stack
 ~ - pop x, move the xth element of the stack
 to the top, removing it from the original spot
 . - output the top value as an ascii character
 , - input ascii character to the stack
 | - discard the top element
 / - pop x, restart the timer of the loop currentdepth - x
 levels deep
If the timer ever reaches the limit in a loop, execution breaks out of that loop and all deeper loops the instruction pointer may be in. This language would be total without the / instruction. The stack contains unbounded non-negative integers. Decrementing from zero is a no-op.
Category:Languages
Category:Stack-based
Category:2022
Category:Unimplemented
%^2^-1

%^2^-1 is an esoteric that relies on using just three main operators: Square the accumulator, take the reciprocal of the accumulator, and divide the accumulator by 100, along with more commands for functional output.
==Backstory==
So this started as this funny thing I do on my calculator where I just insert those keys with the starting accumulator value of one. Then I try to get a specific magnitude. This esoteric is made to be that way where text is outputted that way. It was also heavily inspired by Deadfish but made to be harder is the weirdest way possible. The commands are also made to be nothing correlated with the function, but rather to spell out "simplen't".
==Commands==
 Commands
Text	Function
s 	Divide accumulator by 100
i 	Divide accumulator by 1000 (this allows for the other set of ASCII chars to be printed)
m 	Square accumulator
p 	Reciprocate accumulator
l 	Output accumulator's magnitude as number
e 	Output accumulator's magnitude as ASCII character
n 	Get one ASCII character of input and store into the accumulator as 10^(ASCII value)
' 	Set Accumulator to 1
t 	Restart program is the magnitude of accumulator isn't zero, takes effect when reached
The accumulator also resets the accumulator to one if the magnitude of the number in accumulator is greater than 3003. With the accumulator, again, starting at one always.
Magnitude also just stands for the power of 10 it is. it will always be just 10x, where x is magnitude
Also, ones who are making interpreters should just find a workaround for making the thing not use really large numbers for big magnitudes
==Examples==
The whole language done is zero seconds, AGAIN
===Hello World===
Output in all lowercase. 
 spmmmmmmiiiiiiiieiepssipeepipe'spmmmmemmiiiesiiepipeiieiise'spmmmmpipse
===Cat===
Why did you copy me?????
 net
===Counter===
1 2 3 4 5 6 ... Yea that kind
 spiplt
==Implementations==
A C++ interpreter by User:Bangyen.
Category:Languages Category:Joke languages Category:Unusable for programming Category:Implemented Category:2022
&

& is a joke esolang by User:None1 inspired by ｢Zero Existance⇩｣, if this esolang exists, the interpreter of this esolang will raise a syntax error.
==Examples==
===Raise a syntax error===
 随便写啥都行，我可不管。
==Implementations==
===Python===
 print('Syntax error')
 raise(SyntaxError, "This esolang exists")
Category:Languages
Category:Joke languages
Category:2023
Category:Total
Category:Unusable for programming
&-/

&-/ is an esolang made by emelchenko.
== Commands ==
&-hlwr: prints "Hello World!".
&-halt: ends the program.
&-print: prints a string.
&-variable: declares a variable.
&-printv: prints a variable's value.
==Implementation==
Python
 def ads(program):
 a=program.split("\n");var={}
 while a:
 b=a[0];c=b.split()
 if b=="&-hlwr":print("Hello World!")
 if b=="&-halt":break
 if b[0:8]=="&-print ":print(b[8:len(b)])
 if b[0:11]=="&-variable ":var[c[1]]=c[2]
 if b[0:9]=="&-printv ":print(var[b[9:len(b)]])
 a.pop(0)
 ads("""""")
Category:2023 Category:Languages Category:Output only Category:Total Category:Unusable for programming Category:Implemented
&brainfuck

&brainfuck (pronounced "reference brainfuck") is a brainfuck variant discovered by User:Orby in May of 2020.
==Model==
&brainfuck uses a right-unbounded tape of unbounded non-negative cells. Decrementing a data pointer that is zero, decrementing a cell that is zero, and decrementing an indirection level that is zero all produce undefined behavior.
==Commands==
Command	Action
> 	Increment the data pointer
< 	Decrement the data pointer
* 	Increment the level of indirection
& 	Decrement the level of indirection
[ 	If the cell pointed to by the data pointer is zero, jump after matching ]
] 	If the cell pointed to by the data pointer is non-zero, jump after matching [
The level of indirection begins at zero. At this point all commands behave normally. When the level of indirection is one, > becomes "Increment the cell pointed to by the data pointer". When the level of indirection is two, > becomes "Increment the cell pointed to by the cell pointed to by the data pointer", and so on. Therefore, + can be represented as *>& and - can be represented as *<&. Notice that [ and ] inherently contain one level of indirection, but their level of indirection is also increased with * and decreased with &.
==Reversible variant==
A reversible variant of &brainfuck can be achieved by altering the loop construct.
Command	Action
[ 	If the cell pointed to by the data pointer is zero, jump after matching ]
] 	If the cell pointed to by the data pointer is zero, jump after matching [
To compute the inverse of a program, simply reverse the program string and replace characters according to the following table
Command	Inverse
> 	<
< 	>
* 	&
& 	*
[ 	]
] 	[
==Converting from brainfuck==
Brainfuck programs can trivially be converted to &brainfuck programs, but the converse is not true.
bf	&bf
> 	>
< 	<
+ 	*>&
- 	*<&
[ 	[
] 	]
==See also==
* *brainfuck
* brainfuck
* Befinde
* Symbolic Brainfuck
* Git for reference implementation in C.
* Git branch for Rust implementation with absolute addressing
Category:Languages
Category:Brainfuck_derivatives
Category:Cell-based
Category:Turing complete
Category:Turing tarpits
Category:Implemented
Category:Low-level
Category:2020
'N-DCNC

'N-DCNC was an esoteric programming language designed by
Chris Pressey in 2000 and submitted to the 2001 Esoteric Awards.
It was based on an conspiracy theory involving UFOs, a 5-member boy band,
and an secretive informant code-named "Deep Copy".
The author's original plan was to write the implementation of 'N-DCNC
in Befunge-93, so that it could compete in the
"Best Language Implementation in an Esoteric Programming Language"
category. When that turned out to not be a good plan, the author
implemented it in Perl instead.
==External resources==
* 
Category:Languages
Category:Implemented
Category:2000