nyuuzyou/wikis huggingface dataset:
Anguish

Anguish is a programming language that consists of invisible unicode characters, thus being easy to hide in other programs. The language is essentially brainfuck, with all operators swapped out to invisible characters.
See detailed description here: http://blogs.perl.org/users/zoffix_znet/2016/05/anguish-invisible-programming-language-and-invisible-data-theft.html
And an interpreter here: https://github.com/zoffixznet/perl6-Acme-Anguish/
Category:Brainfuck equivalentsCategory:ImplementedCategory:Languages
AnnoyStack

AnnoyStack is a stack-based language that is purposely created to be difficult to use. It also has an infinite tape, where each cell is of type char.
==Model==
AnnoyStack is modeled as a machine with an right-unbounded tape, and unbounded stack. The tape's cells can be in one of 256 states. Since the stack is modified via the tape, the stack's elements are also in one of 256 states. As with Turing machines, the tape is interacted with via a head which moves along it. The head executes a program, which is a simple list of instructions, along with a looping rule.
==Programs==
All programs must begin with their looping rule:
* repeat X - where X is a bounded natural number of times for the program to loop
* forever - loop the program forever
All programs must also end with:
* end - ends program loop
Loops cannot be used more than once and are required, as the program must be within the loop.
Programs consist of a finite combination of the following instructions, in any order:
Instruction	Behavior
lft 	move the tape left, or do nothing if at the leftmost cell
radd 	move the tape right and add 1 to the cell
push 	push value in current cell to stack
pop 	pop value from stack to current cell
inp 	input keypress to current cell
outp 	output character from current cell
==Example==
Cat program:
 forever
 inp
 outp
 end
Infinitely march without altering the tape:
 forever
 push
 radd
 pop
 end
===ASCII Characters Printer===
This program displays characters in ascending order of their ASCII codes:
 repeat 256
 outp
 radd
 push
 lft
 pop
 end
==Computational Class==
As AnnoyStack can only halt after a fixed number of steps or not at all, it is less powerful than combinational logic. One could imagine a finitely bound combinational logic system, however even so, the available commands cannot create AND, OR, or NOT. Further, even if one could make at least AND/OR and NOT, one could not perform conditional no-ops to fill the remaining loops.
AnnoyStack is not total, as some programs can loop indefinitely.
==Interpreter==
* Common Lisp implementation of the AnnoyStack programming language.
Category:Cell-based
Category:Stack-based
Category:Unusable for programming
Category:Unknown computational class
Category:2020
Category:Implemented
AnnoyingScript

This is a esoteric programming language made by User:AlmostGalactic made in scratch
Check it out here
== Instructions ==
Instructions	Args 	Purpose
+ 	value 	Adds a character or string to the top of the stack
- 	none 	Removes the bottom of the stack
> 	text 	Outputs text to the console
~ 	none 	Returns the bottom of the stack
~\ 	none 	Sets the ~ to blank
< 	none 	reverses the stack
: 	none 	Combines the stack into one string
! 	number 	Jumps to a certain index in the code
? 	value 	Checks if the ~ value is equal to the value, if so, it runs the code in the if
?! 	value 	Checks if the ~ value is not equal to the value, if so, it runs the code in the if
 	none 	End of ? statement
= 	none 	Creates a variable with the value of ~
~( 	number 	sets the ~ value to the value of the variable with the specified number.
=( 	number 	replaces the value of the variable with the specified number to the ~ value
=) 	number 	deletes the variable with the specified number
@ 	number 	returns the value of the variable with the specified number.
{} 	text 	Basically a string. Can only be used in certain instructions.
& 	operator	Does math on the last to items on the bottom of the stack using the specified operator.
# 	none 	Halts the program.
_ 	none 	Asks for the user input. Adds the input to the bottom of the stack
$ 	number 	Gets a random number between 1 and the specified number. Only whole numbers
^ 	none 	Clears the output
; 	seconds 	Waits the specified number of seconds
== Examples ==
=== Hello, World ===
This is the easiest "Hello, World" Statement in AnnoyingScript
>{Hello, World}
Here is a more complex one using more features
+H+e+l+l+o+ +W+o+r+l+d<:~>~
=== Cat Program ===
Here is a cat program
_~>~
=== Truth Machine ===
_~-?1>1!4|>0
=== Calculator ===
+C+a+l+c+u+l+a+t+o+r<:~->~+E+n+t+e+r+ +O+p+e+r+a+t+o+r+ +(+ +++ +-+ +*+ +/+ +%+ +)<:~-_~-=+F+i+r+s+t+ +N+u+m+b+e+r<:~-_~-=+S+e+c+o+n+d+ +N+u+m+b+e+r<:~-_~-=+@2+@3&@1~->~
=== Number Guessing Game ===
+0~-=${10}~-=(1~\^+P+i+c+k+ +a+ +n+u+m+b+e+r+ +b+e+t+w+e+e+n+ +1+ +-+ +1+0<:~-_~-?@1+C+o+r+r+e+c+t+!<:~->~#|+W+r+o+n+g+!<:~->~;1!{15}
Category:Languages Category:2024 Category:Implemented Category:Stack-based Category:Low-level
Another Finite State Brainfuck

Another Finite State Brainfuck is a Brainfuck subset by User:oshaboy designed to be equivalent to an FSA . Because the original Finite State Brainfuck could only check if an input is 1 or 0. Some say Brainfuck without < and > is an FSA but because it can do arithmetic it is more of a Push-down automaton that has a stack limit of 256 unary values.
=== Differences from Brainfuck ===
* The < and > instructions were removed making one cell an accumulator. 
* The accumulator size was thus increased to a long long. (This doesn't help much)
* . prints the value of the accumulator mod 256
* The first + in any sequence of consecutive + sets the accumulator to 0 before incrementing
* - doesn't underflow, attempting to use - when the accumulator is 0 is a NOP. 
* [ ] and , stay the same.
This means you can't count higher than the largest immediate in the program. Which makes it a lot more like a Finite State Automata where you keep count using your position in the code. 
=== Examples ===
Truth Machine
 ,------------------------------------------------[+++++++++++++++++++++++++++++++++++++++++++++++++.]++++++++++++++++++++++++++++++++++++++++++++++++.
=== Implementation ===
https://github.com/oshaboy/Another-Finite-State-Brainfuck
Category:Implemented
Category:Languages
Category:Finite state automata
Category:2021
Category:Brainfuck_derivatives
Category:Accumulator-based
Another Pi Language

Another Pi Language is an esoteric programming language that is based on the bits of Pi. It was designed by Lode Vandevenne in november 2006
The source code of the language exists out of two integers of any size. The first integer indicates the index of the bit of Pi from where we start reading bytes. A value of 0 indicates the program starts being read at the very first bit of Pi that is 1, the most significant one that makes up the "3" before the point. The second integer indicates the amount of bits read. When reading bytes, it should be a multiple of 8.
Starting at the bit of Pi indicated by the first integer of the source code, you start reading the bits in groups of 8 as bytes, or as bits if the chosen source type requires it. Every earlier bit is a more significant bit of bytes. The amount of bits read is the amount given by the second integer.
The bytes read out of Pi, are then interpreted as a single source file of any language (which can also be Another Pi Language). Including third party libraries is possible as long as the device that reads this source code knows where they are installed. Which language the source is in, can be given as extra information together with the two integers.
One question is: does the source code you want to use, appear somewhere in the bits of Pi?
==Example programs==
* According to http://pi.nersc.gov/, the following pair encodes the 16-bit number 42539, which in the language NULL is a cat program.
 (228482784, 16)
* The following pair encodes the 24 bits 001 110 101 010 111 000 011 111, which represents the brainfunct cat program >,.<@/+@, assuming the eight symbols /><+-.,@ are numbered, in this order, from 000 to 111.
 (1749860204, 24)
Category:Languages
Category:Unimplemented
Category:2006
AnruBfiankc

anruBfiankc is an esoteric language by User:Angrylad. It is made to be the most difficult programming language to use. To do this, it uses random number generators to generate a Brainfuck program from your input.
== Generation ==
anruBfiankc uses David Bau's seeded random number generator as well as Ratismal's JavaScript Brainfuck interpreter. Once you type anything into the box, the program takes that code, splits each line into an individual seed, and generates lines of Brainfuck depending on what you inputted. If the Brainfuck interpreter runs into an error, the code is not executed, otherwise, the interpreter executes it, sometimes taking a much longer time.
== See Also ==
*Official page
Category:Languages
Category:Turing complete
Category:Zero-dimensional
Category:Brainfuck equivalents
Ant

:
Ant is an esoteric language, which uses the metaphor of ants walking on a one-dimensional piece of land. Every ant is a thread, with the queen as main thread. A thread ends execution when the command "die" is given. When the queen dies, program execution is stopped.
No interpreter has been written yet, and the syntax is not completely finished.
==Syntax==
In Ant, all whitespace is insignificant, i.e. everywhere a whitespace is allowed, it can be omitted, and vice versa.
A better description of the language features will be given when I figured it out.
==Example==
The following example is an infinite loop, forever printing "Hello world!"
 queen [
 spawn (reaper)
 go right
 ]
 
 class (reaper) [
 take
 eat
 die
 ]
 
 ground [
 72
 101
 108
 108
 111
 32
 119
 111
 114
 108
 100
 33
 10
 ]
Category:Languages Category:Thematic
Ante

Ante is an esoteric programming language where all you've got is a deck of playing cards. The language was created by Michael Dvorkin in 2013. Original Ante interpreter was developed in Ruby, versions in Go, Rust, and Swift are also available.
== Operators, Sequential Precedence ==
 ♦ # Add
 ♥ # Multiply
 ♠ # Subtract
 ♣ # Divide
== Syntax ==
 2-9[x]... # Assignment; the suit of first card designates
 # target register
 A[x] # Current value of register [x] (the Ace aces it)
 K[x] # Jump to the last Q[x] label if A[x] != 0 (go see the Queen)
 Q[x] # Label (the Queen is waiting)
 J[x] # Print A[x] as character (Jack shows the goods)
 10[x] # Print A[x] as number
 
 Kings and Queens can have twins, triplets, etc. of the same suit. While single K♥ goes to Q♥, K♥K♥ twins will go to Q♥Q♥ and so on.
== Examples ==
 #
 # puts "Hello, world!"
 #
 9♦ 8♥
 J♦
 A♦ 2♣ 3♥ 7♠
 J♦
 A♦ 7♦
 J♦ J♦
 A♦ 3♦
 J♦
 5♥ 6♦ 4♥
 J♥
 A♥ 6♠ 6♠
 J♥
 A♦ 8♦
 J♦
 A♦ 8♠
 J♦
 A♦ 3♦
 J♦
 A♦ 6♠
 J♦
 A♦ 8♠
 J♦
 A♥ 3♦ 2♠
 J♥
 A♥ 2♣ 6♠
 J♥
 
 # Run one more time (the same code compacted).
 9♦8♥J♦A♦2♣3♥7♠J♦A♦7♦J♦J♦A♦3♦J♦5♥6♦4♥J♥A♥6♠6♠J♥A♦8♦J♦A♦8♠J♦A♦3♦J♦A♦6♠J♦A♦8♠J♦A♥3♦2♠J♥A♥2♣6♠J♥
 # 15.times { |i| print i }
 3♥ 5♥ # ♥ = 3 * 5
 Q♥ # Label
 10♦ # Print current value of ♦
 A♦ 3♦ 2♠ # ♦ = ♦ + 3 - 2
 A♥ 3♠ 2♦ # ♥ = ♥ - 3 + 2
 K♥ # Jump to Q♥ if ♥ != 0
For more examples check out *.ante files at Ante Github page including Yusuke Endoh's mind-boggling Ante quine (the program that prints itself): Ante Quine
== External resources ==
* Github project page
Category:Languages
Category:2013
Category:Implemented
Category:Unknown computational class
Category:Usability unknown
Category:Thematic
Antgrid

Antgrid is another language devised by Moon (talk) 22:07, 6 May 2016 (UTC)
==Core design==
Antgrid uses a two dimensional grid of data to represent the program, it also supports threading.
===Programs===
programs are represented by grids, like so:
 ++*
 *$*
 *+o
They use different symbols to represent each command
====Commands====
*+: Increment the data under the variable
*-: Decrement the data under the variable
*>: change the pointer on the x axis by 1
*<: change the pointer on the x axis by -1
*[: if the current value under the pointer is 0, skip ahead, obeying * and $ commands until it reaches a ]
*]: if the current value under the pointer is 1, skip back, obeying * and $ commands until it reaches a [
**: changes the direction of execution clockwise or counter-clockwise depending on a special value used by $, if it is 0, clockwise, otherwise counter-clockwise
*$: changes a special value to 1 or zero, depending on the last value
*1: forces the special value to 1
*0: forces the special value to 0
*i: takes input and puts it in the value under the pointer
*0: prints out the value under the pointer
* |: branches the program, initializing a new thread, the new thread has its own version of 'the special value', initialized as 0
* #: kills the thread that runs it
===Samples===
as of now, none exist
Category:Languages
Category:Two-dimensional languages
Category:Unimplemented
Anti-Array

== the idea ==
Anti-Array is a programming language without arrays or stacks.
Instead of either, it allows you to interpret a string as code. This allows you to programmatically create variables.
Example:
 variableName = "{var}"
 loop variableNumber = 0 | variableNumber < 100 | variableNumber ++ |
 ( asCode ( variableName + variableNumber ) ) = variableNumber
 }
 loop variableNumber = 0 | variableNumber < 100 | variableNumber ++ |
 print ( asCode ( variableName + variableNumber ) )
 }
== syntax ==
Each line is made up of tokens. Each token must have a space between adjacent tokens.
=== tokens ===
operators:
* assignment: +=, -=, *=, /=, %=, =, --, ++
* comparison: <, >, ==, !=
* math: +, -, *, /, %
* it performs operations from left to right, ignoring order of operations
commands:
* print
* asCode
# interpret the next string (or string variable) as code, not as a string
# if the string contains \n it will be run, but one asCode is executed it will not execute anything else in that line
* userInput
# gets input from the user
# quotes for string
# number for int
# true/false for boolean
* if
# if boolean
# requires } to close the statement
* loop (statement that runs when initialized) | (condition) | (statement that runs at the end of every loop) |
# parentheses are not necessary
# requires } to close the statement
numbers:
* any sequence of pure numbers will be interpreted as an int
* there are no floating-point numbers
strings:
* anything within quotes
* opening quotes: "{
* closing quotes: }"
boolean:
* false or true
other:
* parentheses
# performs operations inside the parentheses first
* premature line breaks
# use | to act as a line break
variables:
* anything that is not one of the above
* does not require a set type
* internal types are boolean, string, and int
* all variables are global
comments:
* there are currently no comments
== errors ==
* some errors are thrown, but if you try to do something invalid like:
 2 = 100
 102 ++
 anti array
it will ignore it
== examples ==
* factorial:
 total = 1
 factorialNumber = 9
 loop x = 1 | x < ( factorialNumber + 1 ) | x ++ |
 total *= x
 }
 print total
* create array-like variables with 1-100 in them then print them
 baseVariableName = "{var}"
 loop x = 1 | x < 101 | x ++ |
 ( asCode ( baseVariableName + x ) ) = x
 }
 loop x = 1 | x < 101 | x ++ |
 print ( asCode ( baseVariableName + x ) )
 }
* count from 1-99 with asCode
 x = "{loop count = 0 | count < 100 | count ++ |\nprint count\n}}"
 asCode x
* factorial as a function-like
 factorial = "{factorialNumber = "{unset}"\nloop countToTwo = 1 | countToTwo < 3 | countToTwo ++ |\nif ( factorialNumber != "{unset}" )\ntotal = 1\nloop x = 1 | x < ( factorialNumber + 1 ) | x ++ |\ntotal *= x\n}\nprint total\n}\nfactorialNumber = }"
 asCode ( factorial + ( "{10\n}}" ) )
== the interpreter ==
https://github.com/Demonthos/Anti-Array
Category:Languages Category:Implemented
Anti-Machine language

Anti-Machine language is an esolang created by User:None1.
==Execution==
This esolang is the same as brainfuck, except that it cannot run on a machine (e.g. a computer). If you attempt to do that, it will print "Machine detected, fail to run" without quotes.
==Example Programs==
===Quine===
 Machine detected, fail to run
===Self Interpreter===
==Implementations (?)==
===><>===
>i:01-=?v00.
v <
>0r>:~?v"Machine detected, fail to run"v
 ^ <;ooooooooooooooooooooooooooooor<
===brainfuck===
++++++++[->+++[->+++>++++>++++<<<]>>++>>++++>+++++[<]<]>>+++++.>>+.++.+++++.+.<--.>----.>.<-.+.<++++++.>.--.<.>++.-.>>++++.<.<++.-----.++++++++.+++.>.<<.>+++.>.<<--.+++.>-.
===Python===
 print("Machine detected, fail to run")
===JavaScript===
 console.log("Machine detected, fail to run")
===Text===
 Machine detected, fail to run
===Malbolge===
autogenerated at https://www.malbolge.doleczek.pl/#
 '&%$#">~6;:92165.Rsrqponmlk#('~}$#"yx>_^zyxwvutsrk1RQPONMibafedcba`Y}]VUyYXW
 9UTSLpPON0Fj-,+*)('&%$#"!~}|{zyxwvutsrqponm+*)('&%$#cb~`=^]\[ZYXWVUTSRQPONML
 KJIHGcbD`_^]V[ZSRv98TSRQ3ONMLEi,+*)('&%$#"!~}|{zyxwvutsrqponmlkjihgfedcba`_^
 ]\[ZYXWVUTSonPlejihg`ed]#D`YX]Vz=<;:98TSRQ3IHGFKDh+*)('&%$#"!~}|{zyxwvutsrqp
 onmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMcbafedcbaZ_X|?>=<;:9876543210/.-CHAFEDCBA
 @9]~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGcbD`_X]\[TYXQuONS
 LpJONGkK-CHG@?cCB$@?>=<5Yzyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIH
 GFEDCBA@?>=<RQVUTSRQJINGk.-,+*)('&%$#"!~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[Z
 YXWVUTSRQPOkjihgfedc\[`Y}@?>=<;W9OTSRQPONGk.-,+*)('&%$#"!~}|{zyxwvutsrqponml
 kjihgfedcba`_^]\[ZYXWVUqponPlejibgf_%]\"CBA@?>=<;:9876543210/.-,+*)('&%$#"!~
 }|{zyxwvutsrqponm+*)('&%$#zyx`=^]\[ZYXWVUTSRQPONMcbgfedcba`_X|?>Z<RQPUNSRKo2
 10/.-,+*)('&%$#"!~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGc\a
 `_^]\UTYRQub
Category:Implemented
Category:Output only
Category:Brainfuck derivatives
Category:Cell-based
Category:Languages
Category:Joke languages
Category:Nope. derivatives
Category:No-code esolang
Anti-Plushie language

Anti-Plushie language is a language made to be plushie incomplete, by User:None1.
==Commands==
It is the same as deadfish, except these differences:
# If the accumulator will be 4 after a command, instead of executing the command, it prints Fuck off! and halts.
# If the accumulator will be 31 after a command, instead of executing the command, it prints Cut it out! and halts.
# If the accumulator will be 3 after a command, instead of executing the command, it prints Fuck you! and halts.
# If the accumulator will be 2 after a command, instead of executing the command, it prints Oh shit!!! and halts.
Therefore, the language is plushie incomplete.
Added a command: f, which negates the accumulator.
==Example Programs==
===Print Cut it out! with an unusual way===
 dddddsiiiiii
===Print Fuck off! by unbounded accumulator ===
(-2)²=4 is used to avoid the Oh shit!!! case.
 dds
===Print Fuck you! by unbounded accumulator===
 dddf
===Print Oh shit!!!===
 ii
===Print 1===
 io
===Print 9 by cheating(unbounded accumulator)===
 dddso
Note: (-3)²=9
===Print Cut it out! by unbounded accumulator ===
 ddddddsddddd
==Implementations==
*Python implementation
==Note==
Since this esolang is plushie incomplete, it cannot do the XKCD Random Number task.
Category:Languages
Category:Total
Category:Unusable for programming
Category:Joke languages
Category:Output only
Category:Implemented
Category:2023
Category:Deadfish derivatives
Anti-Plushie language/PSTF

PSTF also have another APL(Anti-Plushie Language, not that APL).
== Commands ==
It is same as brainfuck, except:
# If you try to output 4, then it outputs 5.
# If you try to increment on a cell with 1, it becames 3, and vice versa.
# If you try to output 2, then it outputs ↊.
== Example ==
I don't want to write it anymore.
Anti-Plushie language/islptng

islptng's attempt to make a language that has i/o, can perform loop, is Turing- but not Plushie- Complete.
This language is simply brainfuck, but has some additional features to make it Plushie-incomplete.
==Features==
If current cell is 1, it'll be 3 after a + is executed(and vice versa), to avoid storing 2 in a cell.
There is a filter before output. If character is printed after a 4 alone, it prints .1 before printing that. If a 1 is printed after a 3, it prints .1 too.
Anti-myself language

Anti-myself language is an Esolang that designed by PSTF to against his "rule" for an Esolang.
== Command ==
It is just Tau-Alpha-Upsilon except these exception: 
=== Your code is 99 i's and then 99 Sd's ===
It prints "你傻逼吧？" and then halts.
=== Your code includes "h" or "w" ===
It prints "不是，哥们？" and then halts.
=== Your code includes "c" or "f" ===
It prints "操你妈！" and then halts.
=== Your code includes "l" or "r" ===
It prints "我可去你的吧！" and then halts.
=== Your code includes any characters in "><,.[]" ===
It prints "滚蛋！" and then halts.
== Examples ==
=== XKCD Random number ===
 iisS;
=== 不是，哥们？ ===
 h;
=== 滚蛋！ ===
 r[wr]
=== 我可去你的吧！ ===
l>l[d]<S
== See also ==
* Anti-Plushie language
== Categories ==
Category:Languages
Category:Total
Category:Unusable for programming
Category:Joke languages
Category:Output only
Category:2024
AntiDupCall

AntiDupCall is an esoteric programming language.
==Specification==
AntiDupCall has a stack of integer numbers that are at least -1 and the following commands:
Command	Description
< 	Push a -1 onto the stack
+ 	Increment the value at the top of the stack if the stack isn't empty
[ 	Start a loop
] 	End a loop
Each loop has its own integer value when the instruction pointer is inside it. When a loop is entered, its value is set to what it's convenient to set it to for the interpreter, most likely 1. At the start of each iteration, a value is popped from the stack and added to it. The loop runs while the stack is non-empty and its value is at least its value when entering the loop, but this is checked before popping the value, so if it becomes less that the value when entering the loop, it runs for one final iteration before proceeding to the code after it.
If the stack isn't empty when the program ends, it causes an error.
==Examples==
Infinite loop:
 <+[<+]
Another infinite loop:
 <<[+[<+]]
Empty the stack:
 +[+]