nyuuzyou/wikis huggingface dataset:
ABCstr

ABCstr is an esolang by User:ChuckEsoteric08 inspired by Novice.
==Specification==
ABCstr uses string as memory. Initial string is "abc".There are three commands:
 x=y
If there is instance of x in the string replace it with y, else goto label x
 x-y
Works the same but also outputs x if there is x
 :x
Works the same but will replace with user input. It is the only string-rewriting language created by User:ChuckEsoteric08 that has input
==Examples==
===Hello, World!===
 a=Hello, World!
 a
 Hello, World-a
==Computational class==
The language is Turing-complete because there is Cyclic tag interpreter written in it:
a=def
a
:f
f
b=gh
b
:h
h
-
g1
eg=g
gc=g
c=c
gc
d=de
-=-
eg
e;=;e
g0-g
g0
g1-g
-=-
;e
e0=0e
g1=g1
c=0c
-=-
e0
e1=1e
g1=g1
c=1c
-=-
d
c
e1
Category:Languages Category:Turing complete Category:Turing tarpits Category:String-rewriting paradigm
ABG

ABG is an esoteric programming language made by User:ChuckEsoteric08 that uses only 4 commands: a, b, g and c.
==Commands==
Command	Meaning
a 	Increment the current cell and move the pointer to the right.
b 	Decrement the current cell.
g 	Move the pointer to the left and go to the matching c if the current value equals 0.
c 	Go to the matching g if the current cell value does not equal 0.
There is also command for debug: # which outputs cell. Implementing it is unnsecesary.
 gc
is just move pointer to the left and not start loop because there isn't anything between g and c
If you want loop that does nothing, then you need this code:
 g c
==Examples==
===Infinity loop===
 agcg c
It is can be translated to BF like this:
 +><[]
agc is same as + in BF. So BF equivalent is this:
 +[]
===Cat program===
An infinitely repeating cat program is implemented in the following:
 d#agd#aagcc
===Truth-machine===
This program implements a truth-machine:
 d#bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbag
 agcagcagcagcagcagcagcagcagcagcagcagcagcagcagcagcagcagcagcagc
 agcagcagcagcagcagcagcagcagcagcagcagcagcagcagcagcagcagcagcagc
 agcagcagcagcagcagcagcagc
 #bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbaagcc
==ABGAD==
ABGAD is ABG, but with input command d, # outputs as ASCII and command e which halts program.
==Computational class==
BF can be translated to ABG like this:
BF	ABG
+ 	agc
- 	b
> 	ba
< 	gc
[ 	bag
] 	c
==Interpreter==
* Common Lisp implementation of the ABG and ABGAD programming language.
Category:Languages Category:Turing tarpits Category:Turing complete Category:Low-level Category:Implemented
ABPLWNL

Who needs loops?
:- Mario0Fan (2022)
ABPLWNL (or A Bad Programming Language With No Loops) is a Esolang made by User:Mario0Fan
==Commands==
ABPLWNL has only 2 variables and 10 commands
List of commands
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, add 1 from B to A.
5 	Adds the value of B to A and resets B.
6 	Prints the value of B.
7 	Prints a unicode character corresponding to the value of B.
8 	Resets A.
9 	Gets user input and sets B to the number of the input.
a 	Skips the next command if A is equal to 0.
I didn't know what shortcut to give to these commands, so they're numbers and the letter a.
==Examples==
Here are some examples.
===Simple Adder===
 939536
==== How it works ====
First it asks for input (9)
Then it moves the input from B to A (3)
Asks for input again (9)
Adds B to A (5)
The answer is in A so we swap (3) and then print out the value (6)
===Hello World program===
:thats what happens if there are no loops
 11111111111111111111111111111111111111111111111111111111111111111111111137311111111111111111111111111111373111111137731113711111111111111111111111111111111111111111111373222222222222372222222222222222222222223731111111111111111111111113731113732222223732222222237137
This is the shortest hello world program writen in ABPLWNL. Looking at this... brainfuck isn't that hard now
brainfuck's hello world program:
 ++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.
====How it works====
im not even gonna answer that you just put some numbers in and it works
===One Time Cat program===
A cat program repeats what you said. But since you cant input a string, it will repeat a integer you said. And since this esolang has no loops its not forever
 96
====How it works.====
It asks the user for input (9)
and prints it out (6)
==Implementations==
===Interpreter===
The interpreter I made is made in python, and at the end of the program the interpreter prints out the variables (ex. a= 0 b= 4)
Click here to open the interpreter in replit
===Compiler===
The compiler just asks for the code and prints out some python code that will do the same thing as the interpreter would if you run the code.
Click here to open the compiler in replit
]
Category:Total Category:Implemented Category:Unusable for programming Category:2022
ABPLWNL but with stack

:idont need loops but I need a stack lol - Mario0Fan 2022
A Bad Programming Language With No Loops but with stack is a stack-based esolang made by User:Mario0Fan
This language is based off ABPLWNL.
If you don't know what a stack is, go check it out here
==Commands==
If you want to know how this language works, go here.
List of commands
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.
a 	Skips the next command if A is equal to 0
t 	Pushes A onto the stack
u 	Sets A to the top value on the stack, then pops the top value.
e 	Exits the program
I didn't know what shortcut to give to these commands, so they're numbers and random letters.
==Errors==
The python interpreter has 2 errors:
 ERROR 1: Unknown command.
and
 ERROR 2: Stack Underflow
==Examples==
there's currently only 1 example ;-;
===definitely-not-a-truth-machine:)===
 93t3ua6e
If a 0 is inputted, the program ends.
If a 1 is inputted, the program prints one 1 and ends.
====How it works====
It might just seem like gibberish, but its actually pretty simple
Command	How it works
9 	The user is asked for input, then it stores the input into B
3 	It moves the input into A, so then it can be pushed into the stack.
t 	It pushes A (which stores the input) onto the stack, so it can be cloned to B.
3 	Moves A (the input) into B.
u 	Pops the top value of the stack and puts it in A. Now both A and B have the input
a 	Skips the next command if A (the input that was just cloned) is 0
6 	Prints the value of B (the input that was just cloned). Of course, this is skipped if A is 0
e 	Ends this program
im bad at explaining
==Implementations==
Interpreter in Python (replit)
Interpreter for Linux in Python
Category:Total Category:Implemented Category:Unusable for programming Category:2022 Category:Stack-based
ACCUMULATOR

ACCUMULATOR is a programming language designed by UndoneStudios. It was designed mainly to solve the uselessness problem of the accumulator in most languages that have an accumulator. It is a very basic language, though the creator has an interest in developing and improving the language; the last addition was in 20/11/2024, where the E function was added to the JavaScript interpreter. It has 8 operations (in order of addition; the oldest is first):
* A - increments the accumulator
* M - decrements the accumulator
* O - outputs the accumulator
* C - concatenates the accumulator to itself
* R - resets the accumulator to 0
* U - outputs Unicode value of accumulator
* B - backspaces the output
* E - runs the first few characters of the output as ACCUMULATOR code (a rudimentary loop command). The number of characters is the accumulator's value.
This language is case-sensitive. 
== Interpreters ==
=== The official JavaScript interpreter ===
UndoneStudios created this interpreter, which is online at https://sectorcorruptor.github.io/accumulator.html. It is the first interpreter that exists for this language.
=== Python ===
Also created by UndoneStudios
cmd = "++>"
while 1:
 code = input(cmd)
 accumulator = 0
 for i in code:
 if i == "A":
 accumulator += 1
 elif i == "M":
 accumulator -= 1
 elif i == "O":
 print(accumulator)
 elif i == "C":
 accumulator = int(str(accumulator)+str(accumulator))
 elif i == "R":
 accumulator = 0
 else:
 print("Invalid")
Category:Languages Category:Implemented Category:Total Category:Unusable for programming Category:Output onlyCategory:2022
ACHEQUEUENINETHOUSANDPLUS

ACHEQUEUENINETHOUSANDPLUS (aka HQ9000+) is a derivative of HQ9+ that is more powerful than HQ9+:
* H: Print "HELLO MORTAL"
* Q: print every possible HQ9000+ program
* 9: Print the lyrics to "Ascending N Bottles of Beer" (starts with 0 bottles and more bottles are added to the wall)
* +: Increment the accumulator by infinity
==Implementation==
For skilled programmers, implementation of ACHEQUEUENINETHOUSANDPLUS is trivial. It is worth noting, however, that the implementation must be written in the shape of the glyphs H, Q, 9 and plus, or else it will fail to function.
==See also==
* HQ9+, the weaker sibling.
==External resources==
* ACHEQUEUENINETHOUSANDPLUS Interpreter - HQ9+ interpreter hosted on replit. Only accepts valid instructions.
Category:Joke languages
Category:Languages
Category:Output only
Category:Implemented
Category:High-level
Category:2021
Category:Unusable for programming
Category:Accumulator-based
ADxc

ADxc is invented by User:A.
==Example==
Suppose your snippets were AD, xc, 123, and ;l. Then:
* AD should produce 1
* ADxc should produce 2
* ADxc123 should produce 3
* and ADxc123;l should produce 4.
This program would have a score of 4:
Commands	Effects
A 	Push 0.5 onto the stack
D 	Multiply by 2
x 	Push 1
c 	Bitwise left shift by the top of the stack
123 	Push the constants 1, 2, and 3
; 	Summation of the stack
l 	Divide by 2
The top of the stack is output by default.
===Geometric Series===
This program produces the sum of the first five terms of the geometric series, namely the value 1.9375:
 1AAlAllAlll;
==Interpreter==
* Common Lisp implementation of the ADxc programming language.
Category:Languages Category:2019 Category:Stack-based Category:Output only Category:Total Category:Implemented
AEL

AEL (An Esoteric Language) is a WIP esolang by User:Pro465.
 Instructions
Instructions	stack effect 	Meaning
'<char> 	-- char 	push the character following '
: 	x -- x x 	duplicate top item
$ 	x y -- x 	pop
~ 	x y -- y x 	swap
; 	x y -- x y x 	duplicate the second-to-top item
! 	x y -- y x y 	put a copy of the top item below the second item
d 	x ...y n -- ...y x 	dig up the item at n depth
b 	...y x n -- x ...y 	bury the top item into depth n
r 	x ...y n -- x ...y x 	retrieve a copy of the item at depth n
` 	x -- -x 	negate
+ 	x y -- x+y 	add
- 	x y -- x-y 	subtract
* 	x y -- x*y 	multiply
/ 	x y -- x//y 	integer division
% 	x y -- x%y 	modulo
, 	-- byte 	get next byte input
_ 	-- number 	get next numeric input
. 	byte(s) -- 	output byte(s) modulo 256
# 	object -- 	pretty print
@ 	list idx -- list[idx] 	index into a list
& 	list idx x -- list[:idx] ++ [x] ++ list[idx+1:]	set item at index of list
[c] 	-- [c] 	push a list formed by converting the part inside [] to a list of numbers (for the characters) and lists (for the blocks)
? 	n -- [0]*n 	push the list {0, 0, ..., 0} of length n
\ 	list -- prefixes(list) 	push the list consisting of the prefixes of the given list
 	x n -- x[..n] x[n..] 	slice the list at the given position into two
c 	list1 list2 -- list1 ++ list2 	concatenate two lists
w 	x -- [x] 	"wrap" the object to form a list
p 	list x -- list ++ [x] 	push the top item to the list
m 	list c -- <arbitrary> list.map(c) 	push the list formed by mapping the code to the list
e 	list c -- <arbitrary> 	for each element in the list, pushes it to the stack and then executes the code. similar to each in Factor
l 	condblock c -- <arbitrary> 	executes c while executing condblock returns neither empty nor 0.
i 	cond c -- <arbitrary> 	executes c iff cond is neither empty nor 0.
=== notes: ===
# n defaults to 2 for d and b, and to 0 for @ if the top item of the stack isn't an integer, in which case the top item isn't popped before the operation.
== Some Examples ==
=== Fibonacci ===
[edit number in next line to provide input]$
40?
1`1 2d[$!+:]m#
=== Triangular numbers ===
 40?0 0 2d[$1+!+!]m#
Category:Stack-based
Category:Turing complete
Category:2024
Category:Imperative paradigm
Category:Implemented
AETRF

AETRF or An Esolang That Refuses Files is an esolang invented by User:None1. If the program is read from standard input, it's the same as brainfuck, otherwise it will print:
 FILE DETECTED, FAILED TO RUN
==Python interpreter==
import sys
def bf(code):
 s1=[]
 s2=[]
 matches={}
 tape=[0]*1000000
 for i,j in enumerate(code):
 if j=='[':
 s1.append(i)
 if j==']':
 m=s1.pop()
 matches[m]=i
 matches[i]=m
 cp=0
 p=0
 while cp<len(code):
 if code[cp]=='+':
 tape[p]=(tape[p]+1)%256
 if code[cp]=='-':
 tape[p]=(tape[p]-1)%256
 if code[cp]==',':
 tape[p]=ord(sys.stdin.read(1))%256
 if code[cp]=='.':
 print(chr(tape[p]),end=)
 if code[cp]=='<':
 p-=1
 if code[cp]=='>':
 p+=1
 if code[cp]=='[':
 if not tape[p]:
 cp=matches[cp]
 if code[cp]==']':
 if tape[p]:
 cp=matches[cp]
 cp+=1
if sys.stdin.isatty():
 bf(sys.stdin.read())
else:
 print('FILE DETECTED, FAILED TO RUN')
Category:Languages Category:Joke languages Category:2023 Category:Implemented Category:Turing complete
AFTL

AFTL (short for Another Fucking Time Loop) is a stack based esoteric programming language designed by User:Vriskanon. It almost uniquely manipulates its own source code in order to create new code, which is also run.
==Commands==
When AFTL is first run, it will automatically destroy all characters which are not inherently commands themselves. Then, it will run from left to right until the end. It will repeat the code once (unless commanded otherwise) or until it performs "." (which will stop the code).
Whenever a command is run, the code will destroy that command in the source code after completing the command.
Since all whitespace is removed alongside all characters that aren't commands in the code, one can have as much whitespace as they like to make the code clearer.
Command	Description
@ 	Restart the program from the beginning.
. 	Print the entire source code excluding the ".". Exit the program.
< 	Destroy the cell to the left.
> 	Destroy the cell to the right.
( 	Destroy the cell to the left and push its ascii value onto the stack.
) 	Destroy the cell to the right and push its ascii value onto the stack.
^ 	Take the ascii character of the top item of the stack and replace this command with it.
+ 	Add the top two items of the stack.
- 	Subtract the second from top item of the stack from the top item of the stack (top - second from top).
* 	Multiply the top two items of the stack.
/ 	Divide the top item of the stack by the second from top item of the stack (top / second from top)
, 	Take a single character input and push its ascii value into the stack.
" 	Duplicate the top item of the stack.
[ 	Loop beginning (not destroyed).
] 	Go to the corresponding loop beginning and destroy both that and this command.
~ 	Ignore the next cell entirely.
==Sample programs==
===Hello, world! program===
)@"/""+"*"+""*+^
"""+"""+""/+"***+^
"""++""**""/"+"+*"^^
""+""+""/+*""*+""/+^
~,
""+"*"*"+^
"""+"""""/+"""/"++****-^
"""++""/"""++"+"*+*^
""+"""/+"""+*""/+**^
""+""""/+""****^
""+"""+""/+"***^
""+"*"*"++^
.
===Cat program===
,^.
==External resources==
*A Python interpreter.
Category:Stack-based
Category:Languages
Category:2015
Category:Self-modifying
Category:Implemented
AGG

AGG, (pronounced "AAUUGHH!!!!") is a programming language created by mmph that is meant to work like a DNA Strand, except that the codons' real purpose mean nothing in this context and only their abbreviations do.
A command is written as a "codon". A codon is a 3 letter combination that can only consist of A, C, T, and G. A codon can only be 3 letters in length. If it is not 3 letters long it is ignored, and if it is after a "Push" codon, the ignored command is turned into "AAA", or 0. All codons are separated by whitespace.
AGG has 14 codons.
Codon Abbreviation	Command Name 	Command Action
C 	Cout (Pop) 	Pops the top codon from the stack and prints it as a letter with its ascii value.
I 	Input 	Takes input from the keyboard, then for every character that was inputted, it pushes its ascii value to the stack.
P 	Push 	Push's the next codon as a number (explained later).
A 	Add 	Pops the two top codons from the list, then push's their (+) value.
S 	Sub 	Pops the two top codons from the list, then push's their (-) value.
M 	Multiply 	Pops the two top codons from the list, then push's their (×) value.
H 	Modulus 	Pops the two top codons from the list, then push's their (%) value.
D 	Divide 	Pops the two top codons from the list, then push's their (÷) value.
V 	Copy 	Push's the codon on the top of the stack.
T 	Turn (Reverse) 	Reverses the stack.
F 	Forget 	Pops the top codon from the stack and push's it to the memory stack.
R 	Remember 	Pops the top codon from the memory stack and push's it to the stack.
L 	Loop 	Checks if the codon on top of the stack is 0, if it is, it sets the current instructor to its corresponding "Stop" codon.
Stop 	Stop (End Loop)	Checks if the codon on top of the stack is 0, if it is not, it sets the current instructor to its corresponding "Loop" codon.
If the codon is "Push", then it takes the codon after that and turns it into an integer. It does it with this algorithm.
It takes its letters and turns them into numbers with:
*A turns into 0.
*C turns into 1.
*T turns into 2.
*G turns into 3.
Then it converts it from base-4 to decimal.
(Example: TCG -> 213 -> 39).
== Programs ==
So far, there are have only be 3 programs written in AGG.
Hello World
This program prints "Hello, World!" to the console.
 CCT TCA CCC AAT ATG TGT CCA GAT CCG AAT ATG CCT AAC GCT TGC CCC GCT CCA
 AAT ATG GTT GTC GTA TGT TGC CCG AAG GCC GTG TGT CCT TGA TGC CCC TAA TGT
 CCA CGC CCG AAG ATG TGC GTT TGT CCT AAG GCA TGC TGT CCT GAT CCC AAT ATG
 TGC CCA TAC TGT
Cat
This program takes in input and then prints out out again.
 ATA CCT AAA ACC CTT TGT TAA
Truth machine
If you give it a 0, it prints a 0, if you give it a 1, it prints 1 indefinitely.
 ATA CCT GAA TCC CTT CCT AAC CCT GAA GCC TGT TGA CCT GAA GCC TGT
== Interpreter ==
I have coded this before, but I do not know if I will ever get around to releasing it. I just happen to be very lazy.
Category:Languages Category:Stack-based Category:Thematic Category:Implemented Category:2023
AH'TALIQUAE ENGLISH/Examples

Main page: AH'TALIQUAE ENGLISH
== Truth machine ==
START WITH 0.1
DECLARE A VARIABLE truth AND INITIALIZE IT TO NIL
INPUT truth WITH DEFAULT_PROMPT AS PROMPT
IF truth IS TRUE THEN:
 LOOP THE CODES UNTIL truth IS NOT TRUE:
 PRINT "1" WITHOUT NEWLINE
 ENDLOOP
ENDIF
PRINT "0" WITHOUT NEWLINE
THE END
AH'TALIQUAE ENGLISH/News

= Major update! Major update! =
At now time, AH'TALIQUAE ENGLISH supports to control the operating system and network.
You can see AH'TALIQUAE ENGLISH/Extension for more detail!
== SYSTEM Library ==
This standard library implements a series of commands to manipulate the operating system, such as executing batch and DOS commands in the terminal of the operating system, or obtaining the name of the current operating system.
== NETWORK Library ==
This standard library enables online operations, such as connecting to the Internet, accessing websites on the Internet, etc.
AHQ9+-

AHQ9+- is an extension of HQ9+, which adds the following instructions:
* A : print the value of the accumulator;
* - : decrement the accumulator.
==Python intepreter==
accumulator=0
cmds=input(">>> ")
for cmd in cmds:
 if cmd.lower() == "a":
 print(accumulator)
 elif cmd.lower() == "h":
 print("Hello, world!")
 elif cmd.lower() == "q":
 print(cmds)
 elif cmd == "9":
 for i in range(99, 2, -1):
 print(str(i)+" bottles of beer on the wall, "+str(i)+" bottles of beer.\nTake one down, pass it around, "+str(i-1)+" bottles of beer on the wall.")
 print("2 bottles of beer on the wall, 2 bottles of beer.\nTake one down, pass it around, 1 bottle of beer on the wall.")
 elif cmd == "+":
 accumulator+=1
 elif cmd == "-":
 accumulator-=1
input()
==See also==
*HQ9+
*HQ9++
*HQ9+-
Category:Languages Category:Unusable for programming Category:Total Category:Implemented Category:Output only Category:Accumulator-based
AIGenLang

AIGenLang is an esolang prompted by Mihai Popa and generated by ChatGPT (using the GPT-3.5 LLM).
==Command table==
This is the command table:
ADD - Add two numbers
SUB - Subtract two numbers
MUL - Multiply two numbers
DIV - Divide two numbers
PRINT - Output to the console
LOOP - Start a loop
ENDLOOP - End a loop
JUMP - Jump to a specific line
CMP - Compare two values
SET - Set a variable
GET - Get a variable value
IF - Conditional statement
ELSE - Else statement
==Variables==
AIGenLang supports variables that can store values for later use. Variables can be assigned and accessed using the SET and GET commands, respectively. This feature adds flexibility and enables users to work with dynamic data in their programs.
==Loops and Conditions==
The LOOP and ENDLOOP commands allow users to create loops in AIGenLang, enabling repetitive execution of code blocks. Additionally, the IF and ELSE commands provide conditional branching, allowing users to control the flow of their programs based on specific conditions.
==Input and Output==
AIGenLang provides input and output capabilities through the PRINT command, allowing users to display information on the console. Input can be obtained through external means and manipulated within the program, enhancing the interactivity of AIGenLang programs.
==Error Handling==
Error handling is an essential aspect of programming, and AIGenLang offers mechanisms to detect and handle errors. Users can implement error-checking routines and handle exceptions to ensure the robustness and reliability of their programs.
==Advanced Features==
For advanced users, AIGenLang offers features such as functions, recursion, and libraries. Functions allow users to encapsulate code for reuse, while recursion enables elegant solutions for repetitive tasks. Libraries provide pre-built functionalities that users can integrate into their programs, expanding the capabilities of AIGenLang.
This comprehensive overview highlights the key features and capabilities of AIGenLang, empowering users to explore the full potential of this innovative esolang.
==Example Programs==
=== Hello, World Program ===
SET msg "Hello, World!"
PRINT msg
=== Cat Program (Repeats Input) ===
SET input GET
PRINT input
=== Truth Machine Program ===
LOOP
 SET flag GET
 IF flag == 0
 PRINT 0
 ELSE
 PRINT 1
 SET flag 0
 ENDIF
ENDLOOP
=== Fibonacci Sequence Program ===
SET a 0
SET b 1
PRINT a
PRINT b
LOOP
 SET temp b
 SET b ADD a b
 SET a temp
 IF a < 100
 PRINT a
 ELSE
 ENDLOOP
 ENDIF
ENDLOOP
=== Factorial Program ===
SET n 5
SET result 1
LOOP
 IF n == 0
 PRINT result
 ENDLOOP
 ENDIF
 SET result MUL result n
 SET n SUB n 1
ENDLOOP
These example programs demonstrate the versatility and functionality of AIGenLang, showcasing simple tasks like printing messages, repeating input, and computing complex sequences like Fibonacci numbers and factorials.
Category:Languages
Category:Unimplemented
Category:2024
Category:High-level
Category:Generated by AI