nyuuzyou/wikis huggingface dataset:
AIV

AIV is an interpreted weirdlang that uses french quotes instead of brackets.
== Basics ==
=== Sample text ===
Here is a simple test:
display«
The rusted chains of prison moons are shattered by the sun.
»
stop«undisp»
As you can see, we use the symbols « and ». For this, you will have to use Alt+0171 («) and Alt+0187 (»). And also, we don't use print, echo or anything, but it's actually display. And to pause the program, it's the same. It isn't pause or anything, but stop, or stop«undisp», instead.
=== Paused texts ===
As we learnt lately, pausing is done due to the command stop«undisp». Then, we will use it a lot of times in this program:
display«
The rusted chains of prison moons are shattered by the sun.
»
stop«undisp»
display«
I walk a road, horizons change, the tournament's begun.
»
stop«undisp»
display«
The purple piper plays his tune, the choir softly sing;
»
stop«undisp»
display«
Three lullabies in an ancient tongue for the court of the crimson king.
»
stop«undisp»
== Variables ==
=== Sets and counters ===
Now, we're gonna use these different types of variables:
svar«
x=8
»
svar«
y=9
»
count«
xy=x + y
»
display«
The result is %xy%!
»
stop«undisp»
=== Inputs ===
This is how we ask the player a question in a AIV script:
ask«
chocolate=Do you like chocolate (Y/N)? 
»
when«
%chocolate%==Y echo Cool!
»
when«
%chocolate%==N echo Oh...
»
stop«undisp»
Category:Languages
Category:Unimplemented
Category:2015
AI made dis

AI made dis is a esolang created by chatGPT. it was prompted by User:Yayimhere. its named FROSTWIRE-666 although i will use that name elsewhere
== Memory Model ==
The language operates on 666 nodes, each capable of holding an integer. 
These are indexed from 000 to 665 (starting at 0).
There are special registers:
:Demon Register (DR): Holds a pointer to the current memory node.
:Seeding Register (SR): Used for seeding data into other nodes.
:Leeching Register (LR): Used for pulling data from other nodes.
== General Overview ==
FROSTWIRE-666 is an esoteric programming language where the primary focus is on "downloading" and "sharing" data between memory registers, symbolizing file-sharing operations, with an underlying dark theme influenced by the number 666.
The language uses three key concepts: nodes (memory locations), torrents (data transfer commands), and demons (control structures).
== Core Syntax and Commands ==
=== Commands ===
Each command is written as a 3-digit sequence, inspired by the number 666. Here are the basic commands:
 666: Start the program.
Initializes the Demon Register (DR) to 0.
 [Node]666: Download data to a node.
Node is a 3-digit number representing a node. For example, 005666 downloads to node 5.
This copies the value in the Leeching Register (LR) to the specified node.
 666[Node]: Upload data from a node.
Copies the value from the specified node into the Seeding Register (SR).
 999: Seed.
Transfers the value from Seeding Register (SR) to the Leeching Register (LR), allowing it to be used for downloading.
 666666: Demon Summoning (Control Flow).
Acts as a conditional jump. If the value in DR is divisible by 666, jump to the specified memory node.
 [Node]333: Leech data from a node.
Takes the value from the node specified by Node and puts it into the Leeching Register (LR).
 000666: Terminate.
Stops the program.
 666000: Seed and continue.
Seeds the data from SR to LR and proceeds to the next command.
== examples ==
=== Hello, 666: ===
This program loads the number 666 into memory node 001 and outputs it.
666 ; Start the program
001666 ; Download to node 001
666001 ; Upload from node 001 to SR
999 ; Seed (Move SR to LR)
001333 ; Leech from node 001
000666 ; Terminate
=== Demon Summoning ===
This program demonstrates conditional control flow using the 666666 command.
666 ; Start the program
001666 ; Download to node 001
002666 ; Download to node 002
666001 ; Upload from node 001 to SR
999 ; Seed (Move SR to LR)
002333 ; Leech from node 002
666666 ; Conditional jump if DR % 666 == 0
000666 ; Terminate
== Program Flow ==
Program starts at node 0.
The Demon Register (DR) keeps track of the current memory node. Commands can manipulate the flow using the Demon Summoning mechanism, with conditional jumps based on whether the DR value is divisible by 666.
Category:Languages
Category:Unimplemented
Category:2024
Category:Generated by AI
ALIMBIHNN

A Language I Made But It Has No Name
The language is supposed to be similar to English written text and rather easy to use and read. Each line ends with a dot (.) unless it is the end of an if-statement (ends with :) or end of if-clause (ends with ;).
The language operates on cells and a stack. Code is written in lowercase. If-clauses can be nested. A command consists of several words and sometimes require an argument. Input can be a number or a single character. Loops are done with a "jump to line" command (spaghetti). All programs need the "end program." command in order to stop. If the stack is used, the top value is popped. Strings require no ". The "output string" outputs a newline while "output cell as <>" does not.
Interpreter , the alim.py file.
Commands:
Command 	Arguments
set cell as 	<number>, stack, input, file (next char)
push onto stack 	<number>, cell
move pointer to the right. 	None
move pointer to the left. 	None
move pointer to cell 	<number>, cell
output cell as 	number, character (no newline)
output string 	<string> (+newline)
increase cell by 	<number>, stack
decrease cell by 	<number>, stack
multiply cell by 	<number>, stack
divide cell by 	<number>, stack
modulus cell by 	<number>, stack
raise cell to the power of 	<number>, stack
if cell equals 	<number>:, stack:
if cell is less than 	<number>:, stack:
if cell is larger than 	<number>:, stack:
jump to line 	<number>, cell
randomize cell as a number between 0 and	<number>, cell
read file 	<filename>
write to file 	<string>
move file pointer left. 	None (used to re-read characters)
halt program for 	<number>, cell (seconds)
end program. 	None
FIBONACCI
 move pointer to the right.
 set cell as 1.
 push onto stack cell.
 move pointer to the left.
 set cell as 1.
 output cell as number.
 output string .
 if cell is larger than 100:
 end program.;
 push onto stack cell.
 move pointer to the right.
 increase cell by stack.
 move pointer to the left.
 set cell as stack.
 move pointer to the right.
 push onto stack cell.
 move pointer to the left.
 jump to line 6.
Hello World
 output string Hello, World!.
 end program.
Category:Languages
Category:2020
Category:Pseudonatural
Category:Stack-based
ALL

ALL is esoteric programming language by User:IQBigBang. It's Assembly Like Language (ALL). It's based on a lot of instructions with hexadecimal and readable value.
== Memory ==
Memory is cell-based. Cells are saved in 2 dimensional array 256x256. Every cell can store number from 0 to 16 777 216. Cells can be accessed using pointer. Pointer starts on 0x0 cell.
== Instructions ==
=== Basic instructions ===
Here's list of all basic instructions:
Hexadecimal value	Instruction 	Description 	Shortcut
00 	NUL 	Nullating instruction. Does nothing. 	NULlate
01 	REG [registry name]	Calls registry from current source code or from system registry directory (SRD)	REGistry
=== Memory instructions ===
Here's list of instructions working with memory:
Hexadecimal value	Instruction 	Description 	Shortcut
10 	SVM [decimal number]	Saves decimal number to current cell 	Save Value to Memory
11 	REV 	Sets current cell to zero 	REmove Value
12 	MVX 	Moves current cell value to cell next to it in x direction 	Move Value X
13 	MVY 	Moves current cell value to cell next to it in y direction 	Move Value Y
14 	ADD 	Saves sum of current cell and cell next to it in x direction to cell next to current in y direction 	ADD
15 	SUB 	Saves difference of current cell and cell next to it in x direction to cell next to current in y direction	SUBtract
=== Pointer instructions ===
Here's list of pointer instructions:
Hexadecimal value	Instruction 	Description 	Shortcut
20 	NPO 	Moves pointer to 0x0 	Nullate POinter
21 	MOX [decimal x coordinates]	Moves pointer in x direction to entered value.	MOve X
22 	MOY [decimal y coordinates]	Moves pointer in y direction to entered value.	MOve Y
23 	ADX [decimal x coordinates]	Adds entered value to x coordinate of pointer.	ADd X
24 	ADY [decimal y coordinates]	Adds entered value to y coordinate of pointer.	ADd Y
=== Expression instructions ===
Here's list of all expression instructions:
Hexadecimal value	Instruction	Description 	Shortcut
30 	IFE 	Express code between this and next END instruction only if current cell and cell next to it in x direction are equal. 	IF Equal
31 	IFN 	Express code between this and next END instruction only if current cell and cell next to it in x direction are not equal.	IF Not equal
32 	LOP 	Loops code between this and next END instructions (current cell value) times. 	LOoP
33 	END 	End of expression. 	END
Category:2017
Category:Languages
Category:Cell-based
ALLSCII

ALLSCII is a stack-based esolang created by Cortex where every printable ASCII character (excluding whitespace (excluding the space)) is (will be) a valid command. I'm somewhat out of ideas for commands, so if you have an idea for a command feel free to add to the table below.
== Commands ==
Character 	What it does
 	Push 1 to the stack.
! 	Increment the top of the stack by 1.
" 	Increment the top of the stack by 2.
# 	Increment the top of the stack by 5.
$ 	Increment the top of the stack by 15.
% 	Increment the top of the stack by 22.
& 	Increment the top of the stack by 50.
' 	Toggle , !, ", #, $, %, & between incrementing and decrementing.
( 	
Top of stack 	Text printed
0 	"Hello, World!"
1 	"Hello, world!"
2 	99 bottles of beer
3 	Printable ASCII range
4 	One character of string input provided (if no input is left, print 0)
Anything else	The top of the stack as a number.
== Function declaration ==
*In ALLSCII, functions can be defined with this syntax, where * is any character and % is any code:
@*%A
Whitespace is ignored (except spaces, of course). For example, a function that pushes the number 1000 to the stack could look like this:
@K
	&&&&&&&&&&&&&&&&&&&&
A
It would be called like this:
BK
== Examples ==
Note: The first 4 examples were made when ) was the last command in the list.
=== Hello, World! ===
 '!(
=== 99 bottles of beer ===
 !(
=== Quine ===
)
=== Cat program ===
 "!(
=== Truth-machine ===
LC 35"?F 35!?
=== Print "Antidisestablishmentarianism" ===
 ,~ A~
$'".~ n~
'#!.~ t~
'##!.~i~
#.~ d~
'#.~ i~
##.~ s~
'$'!.~e~
$'!.~ s~
'!.~ t~
'$"".~a~
'!.~ b~
##.~ l~
'"!.~ i~
'##.~ s~
'##!.~h~
'#.~ m~
'#"!.~e~
'#"".~n~
#!.~ t~
'$"".~a~
'$".~ r~
'#"".~i~
#"!.~ a~
'$'".~n~
#.~ i~
'##.~ s~
'#!.~ m~
== Truth-machine ==
L~ push number input to the stack ~
C~ while the top of the stack is not 0 ~
 ~ push 1 to the stack ~
44~ multiply it by 4 twice to get 16 ~
!~ increment it by 1 to get 17 ~
?~ print the character with the (for lack of a better term) Unicode value of 32 plus the top of the stack, which is the character 1 (Unicode value 49) ~
F~ end loop ~
~ if the number input is 0, then the while loop was never executed, so if we've gotten this far in the program: ~
 ~ push 1 to the stack ~
44~ multiply the top stack value by 4 twice to get 16 ~
?~ see the previous ? in the code ~
~ end program
Minimized:
LC 44!?F 44?
==External resources==
* Interpreter in Python 3 (not all features are implemented)
Category:Languages
Category:2019
Category:Stack-based
Category:Unknown computational class
Category:Implemented
Category:Pattern-based
Category:Low-level
ALMBARC12YO

ALMBARC12YO is A Language Made By A Really Clever 12 Year Old. It is like Brainfuck but a bit different. I am really smart and clever.
== Why I made it? ==
A few months ago I started to learn python so i could make Minecraft 2 and get really rich and famous. then I discovered brainfuck and thought it was really really cool. So of course, I had to make my own version of it!
== How it works ==
 ALMBARC12YO Commands
Command 	Brainfuck Command
amogus 	+
imposter	-
sus 	>
sussy 	<
vent 	[
among 	]
us 	.
Example 	,
== I am really super clever ==
==Examples==
===Hello, World!===
 amogus vent imposter imposter sus imposter vent sus sus amogus sus
 imposter imposter imposter imposter imposter sussy sussy among sussy
 imposter imposter sussy imposter imposter imposter among sus imposter
 us sus sus sus amogus us sus sus us us amogus amogus amogus vent us
 sus among sussy sussy sussy sussy us amogus amogus amogus us imposter
 imposter imposter imposter imposter imposter us sussy sussy imposter
 us sus sus sus sus amogus us
===Cat Program===
This cat program repeats until a null character input has been issued:
 Example vent us Example among
==Interpreter==
* Common Lisp implementation of the ALMBARC12YO programming language.
Category:Languages
Category:Brainfuck equivalents
Category:Sus
Category:Brainfuck derivatives
Category:Cell-based
Category:Low-level
Category:Turing complete
Category:Thematic
Category:Turing tarpits
Category:Pseudonatural
Category:2022
Category:Implemented
ALPACA

ALPACA is a meta-language designed by Chris Pressey sometime around 1997-1999. The name stands for A Language for Programming Arbitrary Cellular Automata.
The primary motivation for ALPACA was to have a clean and concise notation in which to describe a successor to RUBE, namely REDGREEN. However, ALPACA is capable of describing many common cellular automata. The rules for John Conway's Game of Life, for instance, can be expressed as follows:
 state Dead " "
 to Alive when 3 Alive and 5 Dead;
 state Alive "*"
 to Dead when 4 Alive or 7 Dead.
ALPACA is not, as its name implies, capable of describing truly arbitrary cellular automata; they must be at most 2-dimensional, and exist in a Cartesian geometry. It is, however, capable of describing 2-dimensional cellular automata with a Moore neighbourhood, or any neighbourhood which is a subset of the Moore neighbourhood.
==Computational class==
ALPACA is a meta-language, and thus a direct classification of its computational power is impossible. It can, however, describe John Conway's Game of Life, which is known to be Turing-complete. It might be argued, therefore, that ALPACA is "meta Turing-complete" (that is, able to describe Turing-complete systems.)
Also, any meta-language-plus-input is equivalent to a programming language. So a trivial extension to ALPACA which turns it into a Matrioshka language (like Thue or ODDBALL) would be Turing-complete.
==See also==
* Rule table
==External resources==
* 
* A Metalanguage for Pathological Programming: Cellular Automata in Alpaca
Category:Languages
Category:Meta-languages
Category:Implemented
Category:1998
ALPL

ALPL (A Lambda Programing Language) is an esoteric programming language that was invented by User:Kros.
==Description==
Combinators	Combinators
=x 	(x is any character except whitespace characters or [.]`=?01.) Take one argument and store it in a variable named x. Return the argument.
? 	Take two arguments and one bit from input and return the first argument if the bit received was 1, else return the second argument.
0 	Take one argument and return it, with the side effect of outputting a bit 0.
1 	Like 0 but output bit 1 instead.
Commands 	Commands
`xy 	Apply function x to parameter y.
[p.f] 	Define a function with parameters p that does f. (Every parameter name is one character long and is not whitespace or [.]`=?01.)
== Examples ==
===Print "Hi!"===
 ````````````````````````001001000110100100100000[x.x]
===Cat program===
 `[x.````?10xx][x.````?10xx]
Smaller version:
 `=c[x.````?10xx]`cc
===Hello World===
 `=H[x.````````01001000x]
 `=e[x.````````01100101x]
 `=l[x.````````01101100x]
 `=o[x.````````01101111x]
 `=_[x.````````00100000x]
 `=W[x.````````01010111x]
 `=r[x.````````01110010x]
 `=d[x.````````01100100x]
 `=![x.````````00100001x]
 ````````````Hello_World!_
===Truth-machine===
 `=T[x.`````````00110001Tx]
 `=m[x.````````00110000x]
 ``Tm?
Category:Languages
Category:Functional paradigm
Category:Low-level
Category:Unimplemented
ALT-4

ALT-4 is an esolang by User:PythonshellDebugwindow.
==Commands==
Command	Meaning
0 	Push 0 to the stack
1 	Pop from the stack
01 	If the stack is empty, jump to the matching 10
10 	If the stack is not empty, jump to the matching 01
2 	Scan a filename between this 2 and the next 2 (non-inclusive) and multithread that file
3 	Nop
4 	See Interfile stack manipulation
The programs 01 and 10 both parse into two separate commands, and the program 010 parses into [0, 1, 0] as it would have an unmatched bracket otherwise.
==Multithreading==
When a new file is multithreaded, its instructions execute in parallel with all other multithreaded files. For example, if file F multithreads file G, then every time an instruction in F is executed, an instruction in G is executed right afterwards (execution order is the order the files were multithreaded in). Multithreading by multithreaded files, including recursive multithreading, is allowed. Each file has its own stack, which doesn't get reset when the file finishes executing (stacks don't get kept between multiple runs of the program, however).
==Interfile stack manipulation==
When 0, 1, 01, or 10 is preceded by 4fname4, that command uses the stack of the file fname (or a special "nil stack" that's always empty, even when pushed to, if the file fname hasn't been multithreaded yet) instead of that of its file. This might be enough for Turing-completeness, as one can multithread an empty file to gain access a new stack (e.g., a Minsky machine).
==Examples==
===Empty the stack===
Usable within programs.
 01110
===Infinite loop===
 00110
===Truth-machine===
Prepend a 0 for input 1.
 01010
==Computational class==
Presumed Turing complete; see #Interfile stack manipulation.
Category:Languages Category:2020 Category:Stack-based Category:Unimplemented Category:Unknown computational class Category:Concurrent programming
ALWCIDFEC

ALWCIDFEC(A Language Where Commands Is Different For Each Cell) is variant of 3-cell brainfuck, where as it says in title, commands are different for each cell you use.
==Instructions==
BF / For cell 1	For cell 2	For cell 3
+ 	* 	4
- 	/ 	1
[ 	( 	{
] 	) 	}
==Examples==
===Infinite loop===
Cell 1:
 +[]
Cell 2:
 *()
Cell 3:
 4{}
===A+B Problem===
 ++++**(+/)
Any amount of 's and will be added togeter
==Computational class==
Assuming the ALWCIDFEC interpreter uses unbounded (or unbounded positive) integers, it is trivial to compile a 3-cell brainfuck program into ALWCIDFEC unless it uses unbalanced loops. The Turing-completeness proof for 3-cell brainfuck does not use unbalanced loops, so it also proves that ALWCIDFEC is Turing-complete.
==External resources==
interpreter in Scratch
Category:Languages Category:Brainfuck derivatives Category:Turing complete Category:Low-level Category:Cell-based Category:implemented Category:No IO
AMONGUSISABIGSUSSYBAKAHAHAHAHAHATHISLANGUAGEISREALLYCOOLPLEASEUSEITMYLIFEDEPENDSONITORELSEPLSPLSPLSPLSPLSPLSPLSkahyghdfhm

AMONGUSISABIGSUSSYBAKAHAHAHAHAHATHISLANGUAGEISREALLYCOOLPLEASEUSEITMYLIFEDEPENDSONITORELSEPLSPLSPLSPLSPLSPLSPLSkahyghdfhmILLDIEIFYOUDONTUSEITSOPLEASEUSEITALSODONATETOMYGOFUNDMEBECAUSEIMGONNADIEBECAUSEYOUWONTUSETHISLANGUAGEURTHEIMPOSTORANDTHATISSUSIMGOINGTOCALLAMEETINGONYOUYOUVENTEDYOUSUSSYBAKA, also known as AMONGUSISABIGSUSSYBAKAHAHAHAHAHATHISLANGUAGEISREALLYCOOLPLEASEUSEITMYLIFEDEPENDSONITORELSEPLSPLSPLSPLSPLSPLSPLSkahyghdfhm for short is an esoteric programming language themed to look like a public among us chat. It's interpreter can be found here, the interpreter is for Linux and Windows.
==Language description==
AMONGUSISABIGSUSSYBAKAHAHAHAHAHATHISLANGUAGEISREALLYCOOLPLEASEUSEITMYLIFEDEPENDSONITORELSEPLSPLSPLSPLSPLSPLSPLSkahyghdfhm is a programming language that is very odd, it is more human readable than programming languages like brainfuck, however it is pretty confusing. AMONGUSISABIGSUSSYBAKAHAHAHAHAHATHISLANGUAGEISREALLYCOOLPLEASEUSEITMYLIFEDEPENDSONITORELSEPLSPLSPLSPLSPLSPLSPLSkahyghdfhm consists of 9 unique commands, that allow for some unique programs to be made, however it is very limited. You may not repeat code more than it was wrote in the code, however, you are capable of doing things like generating random integers. Internally, the language was renamed to AmongULanguage, because the executable would not build if it used it's real name.
==Commands==
Command 	Description
GUYS I CAN VOUCH [PLAYER] IS [VALUE] 	Sets variable [PLAYER] to integer [VALUE]
[PLAYER] CAN VOUCH GO AND TELL THEM COME ON 	Prints ascii character of the id of the variable [PLAYER]'s value.
[PLAYER] IS JUST LIKE [SUSSYPLAYER] 	Sets [PLAYER]'s value to that of [SUSSYPLAYER]
IF ITS NOT [PLAYER] THEN VOTE ME 	If [PLAYER]'s value is not 0, execute the next line, otherwise, skip it.
IDK WHAT [PLAYER] IS BUT ITS BETWEEN [MIN] AND [MAX]	Set [PLAYER]'s value to a random integer between [MIN] and [MAX]
[PLAYER] WAS THE IMPOSTOR 	If [PLAYER] is not 0, end the program at that line.
[PLAYER] GOES UP 	Add 1 to [PLAYER]
[PLAYER] GOES DOWN 	Subtract 1 from [PLAYER]
[PLAYER] WHO ARE YOU 	Recieve a character as user input, and save it's ascii value at [PLAYER]
All commands which are not the above commands are fully ignored by the interpreter, and not executed. This can make them useful as comments.
==Example==
===Random Character===
This program utilizes a few functions to generate a random letter.
IDK WHAT GREEN IS BUT ITS BETWEEN 65 AND 90 //Generates random letter
GREEN CAN VOUCH GO AND TELL THEM COME ON //Outputs random letter
=== One Time Cat ===
RED WHO ARE YOU //Asks for input
RED CAN VOUCH GO AND TELL THEM COME ON //Outputs input
Category:Languages
Category:2022
Category:Total
Category:Implemented
Category:Thematic
Category:Unusable for programming
Category:Pseudonatural
Category:Joke languages
Category:Sus
AMiaBF’!?

AMiaBF’?! is an esoteric programming language made by User:AmNow. AMiaBF’?! Is a superset of !aBF' (with a few tweaks)
== Architecture ==
Programs operate on an integer register known as the accumulator.
== Commands ==
Command	Name 	What it does
A 	Between B 	Skip forward to the matching B if the accumulator is 0.
M 	MMMMMM, # 	Print “#”.
i 	i am 1 	Add one to the accumulator. (Roman Numeral: I)
a 	AAAAAAAAAA	Output the accumulator in caps.
B 	Between A 	Jump backward to the matching A if the accumulator is not 0.
F 	Five 	Add 5 to the accumulator.
‘ 	derivative	Set the accumulator to the arithmetic derivative of its value.
! 	not 	Don’t do the next command.
? 	what is it	Prompt the user for an integer and store it in the accumulator.
== Programs ==
=== Truth-machine ===
 ?AaBa
=== Spam console with #s ===
 FAMB
=== Cat program ===
The following presents an infinitely repeating cat program:
 ?aA?aB
=== Arithmetic derivative ===
This program queries the user for an integer, determines its arithmetic derivative, and prints it to the console:
 ?‘a
== Computational Class ==
AMiaBF’!?’s computational class is unknown.
==Interpreter==
* Common Lisp implementation of the AMiaBF’!? 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: 2021 Category:Languages Category:Unknown computational class Category:Implemented