nyuuzyou/wikis huggingface dataset:
Alpha

Alpha is an esoteric programming language that is part of a series by User:Infinitehexagon on Greek esolangs that will be a derivative of the previous esolang with more commands, less commands, or modified commands. So far it has 6 commands. 
Category:LanguagesCategory:2023Category:Output only
==Commands==
Alpha 	Description
+ 	Increment the accumulator by the amount of α(Alpha) following it
- 	reverse the value of the accumulator eg. 72->27. If the reversed value is greater than 255 then set the accumulator to 0.
$ 	output the accumulator's Unicode value
[ 	jump to the "]" instruction by the amount of times α(Alpha) follows it. (Leave blank for infinite loop)
] 	Jump back to the "[" instruction.
a."(instructions)"	read input of instructions and execute them in the program, then append the result into the accumulator
==Alpha Programs==
===Hello World===
~Comments go at the top of the program~
[αααααααααααααααααα+αααα]$[αααα+ααααααα]+α$+ααααααα$$+ααα$+αααααααααααα-+ααααααααααα[αααα+αααα]$-[αααα+αααααααα]$
[ααααα+ααααααααααα]$[ααα+αααααααα]$+ααα$-[ααααααααα+αααααααααααα]$-[αααα+ααααααααααααααααααααααααα]$-[αααα+αααααααα]a$-
===Truth machine===
~Remove the alpha for 0~
+α[αααααα+αααααααα]=[$]
===Print the greek alphabet===
~Multiply 35 by 26 and add 3, then print unicode values 913 to 969.~
[ααααααααααααααααααααααααααααααααααα+αααααααααααααααααααααααααα]
+ααα$[αααααααααααααααααααααααααααααααααααααααααααααααααααααααα+α$]
==Input Problem==
The "a" command does not count as input, as it doesn't necessarily take user input, but takes input as a self-interpreter.
Alphab

Alphab [ˈæl.feɪb] uses every latin alphabet letter. It was created in 2023 by CreeperBomb.
==Syntax & structure==
* Every character has an assigned bit, which start out as zero when a program begins.
* Commands are seperated by whitespace (this will be done by spaces on this page).
* There are four command layouts: all lowercase (flipif), first lowercase (print), first uppercase (jumpif), & all uppercase (query).
* All lowercase will flip the first's bit if the bits of the ones coming after are all 0 (it will always flip if no letters come after).
* First uppercase will jump by the first character's unicode value if the bits of the ones coming after are all 1 (it will always jump if no letters come after).
* If the jump letter has a diacritic, the jump is forewards, otherwise the jump is backwards.
* In all uppercase, the user can choose to flip every specified bit. Multiple letters are required for all uppercase. To flip one value, write it twice (i.e. "AA", "ÜÜ", etc.)
* In first lowercase, multiple letters are, once again, required. The bits are used to print a unicode character, if the first bit is 1. Later bits are higher powers of two.
Notice that flipif runs a nor operation and jumpif runs an and operation. This is useful for thinking about how to do something.
==Useful code & basic programs==
Not a:
 a
Set a to one:
 aa
Set a to zero:
 aa a
A or b on c:
 cc cab
A and b on c (parentheses are for if you want to preserve a & b):
 cc a b c cab (a b)
Hello world program:
 aa aBBBABBA aABABBAA aBBAABAA aBBAABAA aAAAABAA aBBBBBA aAAABAAA aAAAABAA aBABBAAA aBBAABAA aBBABBAA aABBBBA
Category:Languages Category:2023
Alphabet

An alphabet is a finite nonempty set of symbols. An alphabet for a particular language consists of the characters which make up the words of said language. Alphabets form one of the pillars of formal language analysis, aiding in the calculation of Kolmogorov complexity, among other things. 
==Examples of alphabets==
===Binary===
 0 1
===English===
 a b c d e f g h i j k l m n o p q r s t u v w x y z
===Brainfuck===
 + - > < , . [ ]
Category:Concepts
Alphabet Stew

Brainfuck derivative using only letters (a – z) Created by User:DMC
==Concept==
* A stack based esoteric programming language with exactly 26 commands
* Each command is represented by a single character [a - z]
* Numbers [0 - 9] are not used
* Any character not within the set [a-z] is ignored
* whitespace may be used for clarity
==Description==
* an infinite array of cells
* all memory is initialized to zero
* commands that require two values to be pushed will pop two values and push the result onto the stack
* commands that operate on one cell do not use the stack
* '!' diagnostic command to print out memory cells up to highest value of the data pointer, does not have to be implemented
* no effort was made to assign commands to any particular letter
Instruction 	Operation 	Explanation
a 	shift right 	current memory
b 	. 	output ascii
c 	peek 	top of stack
d 	< 	p -= 1, p<0 is an error
e 	increment memory	
f 	jump left 	program counter -= current memory
g 	add 	push two
h 	jump right 	program counter += current memory
i 	] 	close loop
j 	clear stack 	top of stack = zero
k 	xor 	push two
l 	pop 	into current memory
m 	shift left 	current memory
n 	halt 	program stop
o 	push 	from current memory
p 	and 	push two
q 	or 	push two
r 	input decimal 	current cell = input mod 256
s 	> 	p += 1
t 	[ 	open loop
u 	 	
decrement memory	 	
v 	output decimal 	three digit zero filled
w 	exchange 	top two values on the stack
x 	subtract 	push two
y 	not 	(p) = not(p)
z 	, 	input one keypress
==Examples==
===Hello, World!\n===
oemmemosemmmmmeoooog
gseogcosemmmogscosee
emogdeeeossemmememmm
uosemmmmmosemmememmo
ddddouuuoouuuuuuuoss
sosogluuuuoltbli!
===Fibonacci===
First 14 values before it overflows 8 bits
emmmmuuussemmemdvsbdoeodtscvsbdgowdui!
===Truth-machine===
rtsetviiv
==External resources==
*Alphabet Stew – Interpreter written in Python 3
Category:Languages
Category:Brainfuck derivatives
Category:Implemented
Category:Low-level
Category:Turing complete
Category:2018
Alphabet letters

abcdefg....
Alphabet code is written through ascii.
a means add to pointer value
s means subtract from pointer value
m means multiply at pointer value
d means divide from pointer value
z means add value to the "z" stack
c means call everything from the "z" stack
p is the [current] pointer
e means end
So if you were to use only these, you could make a...
Hello World program:
 paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaz
 paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaz
 paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaz
 paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaz
 paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaz
 paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaz
 paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaz
 paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaz
 paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaz
 paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaz
 paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaz
 c
 e
==Interpretter==
interpreted to python and interpreted to go [(by: User:Nmcassa)
Note that these might not handle m and d correctly, as it is not entirely clear what they are meant to do.
Category:Languages Category:2020 Category:Stack-based Category:Implemented
Alphabetack

Alphabetack is an esolang created by islptng. It's plan is to use all 26 characters.
It has a stack and a box. The box can hold any rational.
== Commands ==
a add (box += pop())
b break
c continue
d divide (box /= pop())
e else (used for if)
f function (define a function, the name will be the box)
g get (box = pop())
h halt
i input (box = ord(input()))
j judge (if box != 0:)
k keep (NOP)
l less (if box < 0:)
m modulo (box %= pop())
n negate (box *= -1)
o output (print(chr(box)))
p push (push(box))
q quire length of stack
r reverse
s swap (swap box and top)
t take (pop())
u uno (box = 1)
v visualize (print(box))
w while (while True:)
x exit (to exit while,function,if)
y yield (yield a function called the box)
z zero (box = 0)
Alphabetti spaghetti

Alphabetti spaghetti is an esoteric programming language invented in 2015 by an anonymous user. Programs in alphabetti spaghetti consist of a string of alphabetic characters (letters), hence the name. However, alphabetti spaghetti can only input and output integers. If you wish to output characters, assign each character an integer and transcribe the input and output. Alphabetti spaghetti consists of a pointer on a two dimensional grid of cells. the pointer starts at (0,0) and each cell is initially 0.
== Syntax ==
* a or b: move pointer one space right
* c or d: move pointer one space down
* e or f: move pointer one space left
* g or h: move pointer one space up
* i or j: increment value at pointer
* k or l: decrement value at pointer
* m or n: accept input from user. Store input in current cell.
* o or p: output value of current cell.
* q or r: if cell value equals 0, move to instruction immediately after the next j. Otherwise, continue.
* s or t: if cell value does not equal 0, move to instruction immediately after previous i. Otherwise, continue.
* u or v: multiply value of cell by 10
* w or x: divide value of cell by 10. Discard digits that are after the decimal point.
* y or z: quine function, will output the source code. This is the only place where alphabetti spaghetti will output letters.
Alphabetti spaghetti is not case-sensitive. A letter will perform the same function if it is lower case or capitalized.
== Interpreter ==
An interpreter for Alphabetti spaghetti has been written in C++. However, it is untested. If after testing it is shown to work, it will be uploaded to this site. Another interpreter has been uploaded on that works and follows the syntax except for adding a # token that exits the program.
* Interpreter in C (unrelated to C++ interpreter mentioned above).
Category:Languages Category:Implemented Category:2015
Alphalang

Alphalang is an esoteric programming language made by User:Yes in 2022
== Instructions ==
A		Increment cell
B		Decrement cell
C		Set cell to 0
D		Go back one cell
E		Go forward one cell
F		If cell is 0 go forward one cell
G		If cell is 0 go backward one cell
H		If cell is not 0 go forward one cell
I		If cell is not 0 go backward one cell
J		Get input and store ascii value into cell
K		Output ascii character of cell to the screen
L		If cell is 0 skip next instruction
M		If cell is not 0 skip next instruction
N		Output value of cell as a number to the creen
O		Set cell to 255
P		Divide cell number by 2 and round to the nearest whole number
Q		Multiply cell number by 2
R		Round cell to the nearest 10
S		Round cell to the nearest 100
T		If cell is 0 go to next U
U		If cell is not 0 go to next T
V		Set cell to cell modulo 2
W		Set cell to cell modulo 10
X		Move to first cell
Y		If cell is even set value to 1 otherwise set to 0
Z		If cell is odd set value to 1 otherwise set to 0
== Turing complete ==
Alphalang, is, in fact, turing-complete.
The instructions A, B, D, E, J, K, T, and U are backwards compatible with bf, making it turing complete.
== Examples ==
Hello World (adapeted from bf hello world)
AUBUDDUAUBBBETBUDDDTTTEEEBTEBKBBBKEKKEKDDDDBKDAKEEEEEKEKDDKDBK
Cat program
ATJKU
Truth Machine
JBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAETDUNTAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN
=== Tools ===
bf2alpha
Category:Languages Category:Implemented Category:Turing complete Category:Cell-based Category:2022
Alphamation

Alphamation is joke language.
==Memory==
Alphamation uses a counter, which is an integer and which is initialized to zero.
==Syntax==
Each character in an Alphamation program is its own command, except for @; the number of @s before a command changes its meaning (there can be up to three before a single command).
==Commands==
Command	No @s 	1 @ 	2 @s 	3 @s
& 	Execute a Mirror-machine 	Nop 	Nop 	Nop
+ 	Print Hello,world! 	Print hello world. 	Exit the program 	Print !dlrow,olleH
- 	Execute a cat program 	Execute a reverse cat program 	Read a line of input and discard it 	Set the console's foreground to gray, and execute a reverse cat program
* 	Set the console's background colour to white and its foreground colour to white	Set the console's background colour to white and its foreground colour to red 	Set the console's background colour to magenta and its foreground colour to dark red	Set the console's background colour to dark yellow, write Ç to the console, and then set the console's foreground colour to black
/ 	Reset the console's colours 	Set the console's background colour to white and its foreground colour to green	Set the console's background colour to blue and its foreground colour to cyan 	Set the console's background colour to green and its foreground colour to dark green
; 	Increment the counter 	Double the counter 	Set the counter to 255 	Multiply the counter the counter by four, then increment it
: 	Decrement the counter 	Halve the counter 	Set the counter to 65535 	Floor-divide the counter by four, then increment it
All other characters (including ones prefixed by 1-3 @s), as well as instances of four consecutive @s, are ignored.
==Examples==
===Hello, World!===
+
===Cat===
-
===Reverse cat===
@-
==Implementations==
*Alphamation source code
Category:Languages
Category:Total
Category:Joke languages
Category:Unusable for programming
Alphaprint

Alphaprint is a language made by User:PythonshellDebugwindow.
==Syntax==
The program is made up of an arbitrary-size repeating lowercase string of the alphabet starting with a (with some uppercase letters; see #Output), e.g. abcdefg would be a valid program but abcdefh, lmnop, or zyxwvut wouldn't be.
==Output==
Any uppercase character will output the ASCII character of its position in the code modulo 256. For example,
 abcdefghijklmnopqrstuvwxyzabcdefgH
would output the character ! because the capital 'H' is the 33rd character in the source code, and the ASCII code of ! is 33.
==Hello, World!==
 abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstUvwxyzabcdefghijklmnopqrstuvwXyzabcdEfghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzAbcDefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijKlmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstUvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwXyzabcdefghijklmnopqrstuVwxYzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnOpqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabCdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghiJ
==Resources==
* An interpreter and code generator are available on GitHub.
Category:Languages Category:Implemented Category:2020 Category:Output only Category:Unusable for programming Category:Total Category:Finite state automata
Alternating 1-based Minsky machine

An Alternating 1-based Minsky machine (A1MM for short) is pedestrian variation on a Minsky machine which was defined by Chris Pressey
in 2024 with the intent of being used as an intermediate language to ease writing Turing-completeness proofs for certain languages. In particular, A1MMs are used in the Strelnokoff Turing-completeness proof.
==Definition==
An Alternating 1-Based Minsky machine is just like a Minsky machine, except
* Along with the increment and decrement instructions, there is also a NOP instruction. You can think of it being like increment, except instead of adding 1 to the counter, it adds 0. (And of course it is not necessary to identify a particular counter in this case.)
* The smallest value a counter can take on is 1.
* The "decrement" instruction tests the counter for being 1 instead of being 0.
* All counters start with the value 1.
* All steps must be numbered with integers.
* Even-numbered steps may only transition to odd-numbered steps, vice-versa. This applies to all transitions out of the step, i.e. both transitions out of a decrement instruction must follow this rule.
==Computational class==
It should not be difficult to see that every Minsky machine can be converted to an equivalent Minsky machine by:
* offsetting all values by +1, i.e. anywhere there is a 0 in the Minsky machine, there will be a 1 in the A1MM.
* rearranging the steps so that all even-number steps transition only to odd-numbered steps and vice versa, inserting extra NOP steps as needed to avoid transitioning to another step of the same parity.
==See also==
* Minsky machine
* Strelnokoff
Category: Computational models
AmBored

AmBored is an esoteric language written by User:Is this the Krusty Krab. It is a Brainfuck derivative written in C++ which adds more commands and features primitive graphics. It was named so due to the fact that I am bored, so I am making this for fun. (The author has neither confirmed nor denied if it is also a pun on 'board', given that the program state is like a blackboard.)
== Features ==
AmBored has an array the size of 256 by 256 cells, each cell represents a color.
Another two feature of AmBored are a stack, which operates like a normal stack you probably studied in school, college, or your room at night instead of sleeping, and a buffer able to store a value to be used later.
== Syntax ==
The syntax is classic Brainfuck syntax, with a few changes and additions.
CMD 	Description
> 	Move the memory pointer right
< 	Move the memory pointer left
V 	Move the memory pointer down
^ 	Move the memory pointer up
+ 	Increment the pointed cell's colour
- 	Decrement the pointed cell's colour
[ 	Jump past the matching ] if the pointed cell is 0 (black)
] 	Jump back to the matching [ if the pointed cell is nonzero (not black)
, 	Input a number and write it to the pointed cell
. 	Refresh the screen
( 	Push the value of the pointed cell to the stack
) 	Pop the top value of the stack to the pointed cell
@ 	Assign the value at the top of the stack to the pointed cell
$ 	Pop the top value of the stack without writing it to the pointed cell
{ 	Rotate the value of the pointed cell to the left
} 	Rotate the value of the pointed cell to the right
/ 	Store the value of the pointed cell into the buffer
\ 	Write the value of the buffer to the pointed cell
0 - 7	Store the color corresponding to the number in the pointed cell.
== Interface ==
As mentioned, the output is a screen of pixels, each with the color stored in them. There is also a command to refresh the screen. This is because the screen needs to be refreshed manually, to prevent the user from seeing the whole process of changing the frame.
Why? Because I said so.
The colors that can be represented by the pixels are:
Number	Binary (RGB)	Color
0 	000 	Black
1 	001 	Blue
2 	010 	Green
3 	011 	Cyan
4 	100 	Red
5 	101 	Magenta
6 	110 	Yellow
7 	111 	White
== Ay btw ==
If you create something serious with AmBored, please send it to me at harambethereligiousgorilla@gmail.com so I can add it to this page and give you credit.
==Interpriter==
User:Monochromeninja made a python 3 interpriter. Try it out!
==See also==
*AmBored++
*AmBored--
Category:Languages
Category:Brainfuck derivatives
Category:Two-dimensional languages
Category:Stack-based
Category:Implemented
Category:Turing complete
Category:Graphical Output
Category:2018
AmBored++

AmBored++ is an esoteric language written by Is this the Krusty Krab. It is a Brainfuck derivative written in C++ which adds more commands and features primitive graphics. It was named so due to the fact that I am bored, so I am making this for fun, and because it has more features than AmBored.
== Features ==
AmBored has an array the size of 256 by 256 cells, each cell represents a color.
Another two feature of AmBored are a stack, which operates like a normal stack you probably studied in school, college, or your room at night instead of sleeping, and a buffer able to store a value to be used later.
== Syntax ==
The syntax is classic Brainfuck syntax, with a few changes and additions.
CMD 	Description
> 	Move the memory pointer right
< 	Move the memory pointer left
V 	Move the memory pointer down
^ 	Move the memory pointer up
+ 	Increment the pointed cell
- 	Decrement the pointed cell
[ 	Jump past the matching ] if the pointed cell is 0 (black)
] 	Jump back to the matching [ if the pointed cell is nonzero (not black)
, 	Input a number and write it to the pointed cell
. 	Refresh the screen
( 	Push the value of the pointed cell to the stack
) 	Pop the top value of the stack to the pointed cell
@ 	Assign the value at the top of the stack to the pointed cell
$ 	Pop the top value of the stack without writing it to the pointed cell
{ 	Rotate the value of the pointed cell to the left
} 	Rotate the value of the pointed cell to the right
/ 	Store the value of the pointed cell into the buffer
\ 	Write the value of the buffer to the pointed cell
[number in base 64]	Store the color corresponding to the number in the pointed cell.
== Interface ==
As mentioned, the output is a screen of pixels, each with the color stored in them. There is also a command to refresh the screen. This is because the screen needs to be refreshed manually, to prevent the user from seeing the whole process of changing the frame.
Why? Because I said so.
There are 64 possible color combinations, with each pixel taking 6 bits and each color taking 2 bits of a pixel.
== Ay btw ==
If you create something serious with AmBored, please send it to me at harambethereligiousgorilla@gmail.com so I can add it to this page and give you credit.
==See also==
*AmBored
*AmBored--
Category:Languages
Category:Brainfuck derivatives
Category:Two-dimensional languages
Category:Stack-based
Category:Unimplemented
Category:Turing complete
Category:2018
Category:Graphical Output