nyuuzyou/wikis huggingface dataset:
A^2+b^2=c^2

a^2+b^2=c^2 or trianguler theorems is a esolang/computer created by User:Yayimhere for no reason
== memory ==
memory is stored as a 12 nibble high triangle. each triangle has a hexadecimal word with 23 digits. this word points to a spesific triangle.
=== hexadecimal triangle ===
 0
 000
 00000
 0000000
 000000000
 00000000000
 0000000000000
 000000000000000
 00000000000000000
 0000000000000000000
 000000000000000000000
 00000000000000000000000
(and so on)this is the triangle. there is a pointer that points to the layer thats being modified. each digit can be any number from 0-f
=== operations/ISA ===
there is a few stupid commands:
* MJMP: jump to the triangle with the word equal to the current row with trailing 0's for all the missing width
* MV: move down as many rows as whats the current row is equal to
*LWJ goto the word to the left
* RR: reverse the current row
* SHL: do the current row SHL the row below
* MT: set the current row to a string of f's if its more than the row below else set it to a string of 0's
* CJMP: jump back as many chars as the row below if the row above is more than 0
* ETTAO: encrypts the current row to ascii using the nibble table(each pair of nibbles in the current row)
* IBRB: increment current row by the row below
* IBO: increment current row by 1
* DBO: decrement current row by 1
* ONMW: output the current row encrypted or not
* RIS: if the current row is ascii encrypted reverse the string
* SRTFSUOC: set the current row to the following chars(needs to be of the same width as current row) until the next command
* OANO: a no-op
* DFAIAOITES: if current row is encrypted to ascii decrypt it
=== notes ===
* the pointer points to a row
* there is another pointer that points to a word
* there are infinitely many words extending to the left
* on the table at (c:B, r:9) there is a space but at (c:B, r:A) there is nothing or a unprintable char. and at (c:C, r:C) there is a space after the t
Category:Unknown computational class Category:Low-level Category:Languages
A "real" esolang

A "real" esolang is an esolang made entirely of vegetables.
== How it works ==
 pea +
 corn -
 greenbean >
 broccoli <
 cauliflower [
 zucchini ]
 lettuce .
 spinach ,
== Ascii loop ==
 pea cauliflower lettuce pea zucchini
== Origin ==
People were saying that esolangs are not "real", and if "real" food is made of vegetables, then clearly an esolang made of vegetables would be "real".
Category:LanguagesCategory:PseudonaturalCategory:Brainfuck equivalentsCategory:Joke languagesCategory:Brainfuck derivativesCategory:Turing completeCategory:Cell-basedCategory:Low-level
A Pear Tree

A Pear Tree is a trivial derivative of Perl created by User:ais523 in 2016, mostly as a joke. It aims to mildly modify the language to make it more suitable for writing polyglots (i.e. programs that run correctly in more than one language), particularly with Python 3.
The semantics are identical to Perl, except that:
* Various options are set automatically depending on the presence of input on standard input and on the presence of the letter F in the program;
* Scalar variables can often be used without the leading $ on their names (see the documentation in the reference interpreter for details);
* When omitting the leading $, scalar variables that hold array references can be dereferenced with suffix [index] notation;
* print works like Python (adding a trailing newline, and placing spaces between its arguments);
* A repr function exists, that returns a string representation of its argument.
Additionally, before running the program, the source code is potentially rotated by moving some of the code from the start to the end (or equivalently, vice versa). The point that becomes the new start of the program is determined by checking all substrings of the program to see if they have a CRC-32 of zero (this condition was chosen because it's easy to bring about intentionally – CRC-32 is not secure against preimage attacks – but unlikely to happen by chance). The start of the longest such substring becomes the start of the program. If there are no appropriate substrings, the interpreter prints a partridge and exits, rather than running the program.
== External resources ==
* An interpreter (in Perl, obviously) is available here (older version, which doesn't handle array indexing).
Category:LanguagesCategory:2016Category:Turing completeCategory:ImplementedCategory:High-level
A Question of Protocol

A Question of Protocol is a esolang created by User:Yayimhere where its all just substacks, n' more substacks, yea stacks are very use full when nested for some reason
== syntax ==
these are the commands:
* $x: pop top of stack. if empty goto line x
* #: push substack to stack
* }: move the top of the stack to the bottom of the stack and { rotates the other way
* =: push a sub-substack to the top substack of the stack
* (x): = but with nesting x
* (x[y]): !y but with nesting x
* !x: pop the top of the top substack. if empty goto line x
* *: run top of stack as a macro also popping it
* h: halt
* %: duplicate top of stack
* ^: print top of stack as an ascii char(see ints) also popping it
* ?: print but user INPUT
all nesting values start at the outermost stack(just the stack) has a value of 0
== macros ==
(here i will be using python's list format where the end of the list is the front of the stack)
this is the structure(in a substack):
 [[[cmd1][[arg1][arg2]...]][[cmd2][[arg1][arg2]...]]]
where each cmd i run in order.
here numbers are represented with how many stacks there are in a substack. so for 5 it would be [][][][][]. here are the commands:
* $x: cmd(nesting number): 2, arg1: x
* #: cmd: 1
* }: cmd: 3 
* }: cmd: 5
* =: cmd: 7
* (x): cmd: 4, arg1: x
* (x[y]): cmd: 6, arg1: x, arg2: y
* !x: cmd: 8, arg1: x
* *: cmd: 9
* h: cmd: 11
* %: cmd: 13
== computational class ==
A Question of Protocol is turing complete since it can simulate a Minsky machine:
* the code must start with ##
* } to swap between registers
* !x to decrement. if at 0 will go to x
* = to increment
== ints ==
ints can be represented like this:
* lets say we have int n
* as a substack with n many lists in it
* now we have a integer
== example ==
Infinite loop:
 $0
or using macros:
 #=(3)(3)(3)(3)(3)(3)(3)(3)(3)=(3)(3)(3)(3)(3)(3)(3)%*
which creates macro: 
 %*
Category:Languages Category:Functional paradigm Category:Stack-based Category:Turing complete Category:Turing tarpits Category:Low-level
A Queue which can't grow

A Queue which can't grow (AQWCG) is an esolang by User:ChuckEsoteric08.
==Specification==
A Queue which can't grow uses a queue of integers to store data. Its initial state is set to user input with elements being seperated by ;There are only two (three counting \ which is a nop) commands:
 |
Which dequeues element, increments it, and enqueues result
 /
Which dequeues element, If it's nonzero decrements it, and enqueues result. If it's zero it would enqueue zero and jump forward to matching \Program never halts.
We could also define language so that it would use tape instead of queue:
 |
Increments cell and moves right
 /
If current cell is nonzero decrement it, and moves right. If it's zero it would move right and jump forward to matching \
==Examples==
===Counter===
This counter program simply increments all of the user inputs in a perpetual manner:
 |
===Adder===
The following program expects two numbers, incrementing the second by the first one's value, and repeating the process by a reversal of the roles:
 /|\
==Computational class==
AQWCG is Turing-complete because it's possible to translate Minsky machines to it. For simplicity we would use notation where x is length of a Queue and (commands:x) would execute commands x times.We could define command INC2 which would move left and increment cell:
 INC2 = (|:x)(/\:x-1)
DEC2 would decrement instead:
 DEC2 = (|:x-1)(/\:x)
SKIP code ENDSKIP would execute code if cell is nonzero. Note that code should end with pointer pointing to the same cell.
 SKIP code = / INC2 code |
 ENDSKIP = \ DEC2
It's enough commands to compile Minsky machine to it. Queue is initialised as 0 followed by initial values of Minsky machine registers. That 0 is used as Instruction pointer for Minsky machine program.
==Interpreter==
* Common Lisp implementation of the A Queue which can't grow programming language.
Category:Languages Category:Turing complete Category:Turing tarpits Category:Queue-based Category:2023 Category:Implemented
A Simple Language With A Console

== Introduction ==
A Simple Language With A Console, is an esoteric programming language created by Fly and it's just, as the name suggests, a simple language in a console made in python 3.
Also check A Simple Language With A Console Except There Is No Console
== Instructions ==
Instruction 	Description!
say 	it can output text, numbers and values from the memory
tell 	it can input text or numbers and store those values in the memory
store 	it stores any value in the memory
label 	it can name the values of the mamory
forget 	it can remove the last value in memory and label or everything
all(forget) 	(if used with the command forget) deletes every value in the memory and label
remember(say)	(if used with the command say) by giving the index of an element in the memory it can output it
recall(say) 	(if used with the command say) by giving a label name it can output the value in the memory at the index of the label
last(say) 	(if used with the command say) it outputs the last value of the memory
== Examples ==
=== Hello World ===
 >> say Hello, World! 
=== A simple program ===
>> store test
>> label example
>> say recall example
OUTPUT: test
== Computational Class ==
It's still not finished but for now, due to the absence of loops or conditional statements, this language is not in any way turing complete.
== Implementations ==
you can try this project with this python code.
memory=[]
labels=[]
while True:
 code = input(">> ")
 if code.startswith("say"):
 if "remember" in code:
 if "last" in code:
 print(memory[len(memory)-1])
 else:
 index = int(code.replace("remember","").replace("say","").strip())
 print(memory[index])
 elif "recall" in code:
 index = labels.index(code.replace("say","").replace("recall","").strip())
 print(memory[index])
 else:
 print(code.replace("say","").strip())
 if code.startswith("tell"):
 memory.append(input(code.replace("tell","").strip()))
 if code.startswith("store"):
 memory.append(code.replace("store","").strip())
 if code.startswith("label"):
 labels.append(code.replace("label","").strip())
 if code.startswith("forget"):
 if "all" in code:
 memory.clear()
 labels.clear()
 else:
 memory = memory[:-1]
 labels = labels[:-1]
Category:Languages
Category:Total
A Simple Language With A Console Except There Is No Console

== Introduction ==
A Simple Language With A Console Except There Is No Console, is an esoteric programming language created by Fly and it's just, as the name suggests, A Simple Language With A Console but with no console(basically the same exact thing).
== Instructions ==
Instruction 	Description!
say 	it can output text, numbers and values from the memory
tell 	it can input text or numbers and store those values in the memory
store 	it stores any value in the memory
label 	it can name the values of the mamory
forget 	it can remove the last value in memory and label or everything
all(forget) 	(if used with the command forget) deletes every value in the memory and label
remember(say)	(if used with the command say) by giving the index of an element in the memory it can output it
recall(say) 	(if used with the command say) by giving a label name it can output the value in the memory at the index of the label
last(say) 	(if used with the command say) it outputs the last avlue of the memory
== Examples ==
=== Hello World ===
 >> say Hello, World! 
=== A simple program ===
>> store test
>> label example
>> say recall example
OUTPUT: test
== Computational Class ==
It's still not finished but for now, due to the absence of loops or conditional statements, this language is not in any way turing complete.
== Implementations ==
you can try this project with this python code.
import sys
file = open(sys.argv[1],"r")
memory=[]
labels=[]
for code in file:
 if code.startswith("say"):
 if "remember" in code:
 if "last" in code:
 print(memory[len(memory)-1])
 else:
 index = int(code.replace("remember","").replace("say","").strip())
 print(memory[index])
 elif "recall" in code:
 index = labels.index(code.replace("say","").replace("recall","").strip())
 print(memory[index])
 else:
 print(code.replace("say","").strip())
 if code.startswith("tell"):
 memory.append(input(code.replace("tell","").strip()))
 if code.startswith("store"):
 memory.append(code.replace("store","").strip())
 if code.startswith("label"):
 labels.append(code.replace("label","").strip())
 if code.startswith("forget"):
 if "all" in code:
 memory.clear()
 labels.clear()
 else:
 memory = memory[:-1]
 labels = labels[:-1]
Category:Languages
Category:Total
A Slow Language

A Slow Language is a 2D esoteric Fungeoid made for a Truttle1 Esolang Jam. You control a turtle on an infinite grid. And since turtles are slow, it randomly takes 1 to 3 seconds before it moves on to another cell.
== Instructions ==
When any value on the stack is used by an instruction, it gets popped! Only in popping mode, which is internally on. *You can toggle it with a dot. (.)
Character 	Function
r 	Sets the turtle's direction to right.
l 	Sets the turtle's direction to left.
u 	Sets the turtle's direction to up.
d 	Sets the turtle's direction to down.
= 	Performs IF condition. If the top value matches the value below it, it moves right, otherwise it moves left.
 	Same as equals to, but when the top values match, it moves up, otherwise down.
_ 	If there's no value on a stack, it moves to the left, otherwise it moves right
! 	Same as underscore, but it performs it vertically like the pipe instruction.
? 	Chooses a random direction to walk in.
" 	Toggle stack pushing mode. In stack pushing mode, the turtle pushes any character's ASCII value onto the stack.
Any hexadecimal number from 0 to F (letters must be uppercase)	Pushes a number onto the stack.
v 	Pops a value from the stack.
^ 	Pushes a the current top value onto the stack (Duplicate)
~ 	Reverses the stack
O 	Prints the top value on the stack as an ASCII character.
o 	Prints the top value on the stack as a number.
I 	Reads user input as ASCII characters and pushes the values onto the stack.
i 	Reads user input as number and pushes the value onto the stack.
+ 	Adds the top 2 values on the stack together and pushes the result.
- 	Subtracts the top 2 values on the stack together and pushes the result.
* 	Mutliplies the top 2 values on the stack together and pushes the result.
/ 	Divides the top 2 values on the stack together and pushes the result.
% 	Modules the top 2 values on the stack together and pushes the result.
x 	Ends this program.
. 	Toggles popping mode.
: 	Reads/Writes into a register. More info in the Register section.
=== Register ===
Register is used as another form of data storage. It can be written or read from. Register is identified with a character after the : instruction. When the register is empty (contains no value), it is written to from the top value in the stack (then popped if in popping mode). If it contains a value, then it will push it's value onto the stack and marks it as empty.
== Examples ==
=== Hello World ===
r"Hello, World!"~d l
 x_Ou
89*OAA*1+OAA*8+^OOAA*A+1+O4A*4+O84*OA8*7+OAA*A+1+^O3+OAA*8+OAA*O84*1+O
=== Truth Machine ===
ri1 d
 xo0=r1od
 u l
=== Cat Program ===
rI~d l
 x_Ou
== Interpreter ==
* Download
* View Source
=== Changes ===
* Added new instruction: "." - Toggle popping mode
* Added new instruction: ":" - Reads/Writes into a register. More info in the Register section.
Category:Languages Category:Implemented Category:Two-dimensional languages Category:Stack-based
A Triple Sharp

A𝄪# is A triple sharped(A, bB, B, C), So its syntax is same as C. (I added something in it.)
== Syntax ==
Same as C and C++.
== Programs ==
=== Hello, world ===
#include <stdio.h>
void main()
{
 puts("Hello, world!");
}
=== 99 bottles of beers ===
#include <stdio.h>
#include <windows.h>
#include <string.h>
#include <iostream>
using namespace std;
string unit = "bottles";
void main()
{
 for(int i = 99; i > 0; i--)
 {
 unit = (i > 1) ? "bottles" : "bottle";
 cout << i << " " << unit << " of the beers on the wall, " << endl;
 cout << i << " " << unit << " of the beers. " << endl;
 puts("Take 1 down, pass it around, ");
 if (i - 1 == 0)
 {
 cout << "No more bottles of the beers on the wall." << endl << endl;
 }
 else
 {
 cout << (i - 1) << " " << unit << " of the beers on the wall. " << endl << endl;
 }
 }
 puts("No more bottles of the beer on the wall, \nNo more bottles of the beer. ");
 puts("Go to the store and buy some more, \n99 bottles of the beers on the wall.\n");
}
== Categories ==
Category:Languages
A Very BASIC Esolang

A very BASIC esolang is an esolang made by User:DifferentDance8 to push the "Pseudonatural" category to it's absolute limits. Unlike TWFUN, an earlier esolang made by the same person, the name of this esolang was ironic on purpose. (Looking back on it, it's extremely similar in concept to Esolang Simply Created To Annoy People Who Dislike Scratch, but wildly differs in execution)
== Commands ==
 Commands
Command 	Description
START PROGRAM 	Starts the program
PRINT OUT THE CURRENT STRING "string" 	Prints out the string
ASK USER FOR INPUT 	Asks user for input
GOTO [line number] 	Goes to a line number
PLAY NOTE [note letter] [volume] [pitch]	Plays a note
EXIT 	Exits a program.
== Example Programs ==
Hello World:
START PROGRAM
PRINT OUT THE CURRENT STRING "Hello, World!"
EXIT
Cat Program:
START PROGRAM
ASK USER FOR INPUT
PRINT OUT THE CURRENT STRING input
(note: there is no way to exit out of this cat program)
Category:Pseudonatural
Category:Audio_Output
Category:Languages
Category:2024
Category:Unimplemented
Category:High-level
Category:Unusable for programming
A simple point and click language…?

This language uses my game on scratch as syntax for an esolang
== Commands ==
 Key:
 ! Is self explanatory
 Commands:
 up
 down
 left
 right
 (those move in a 2d grid)
 win
 (goes out a level)
 level
 (goes in a level)
 no
 (noop)
 no to win
 replace to no
 left to right
 right to left
 up to down
 down to up
 (!)
 Commands not from my game:
 Place number (x)
 (places a number with value x at this spot)
 Remove number
 (removes it)
 Store number
 (stores this number in temp)
 Load number
 (places the temp value at this spot)
 Print
 (prints the temp value)
== Examples ==
 up
 right
 level
 up
 place number 5
 store number
 win
 left
 down
 print
 load number
Category:Languages Category:2024 Category:Pseudonatural
Aaargh++

Aaargh++ (for Aargh plus 2 dimensions) is the language I'm working on right now. It's gonna be 4d. These are the specs:
==Goals==
*4d grid/code/data-array - entire folder with "planes".
*Stack can be pushed to cell.
*Stack can be imported from cell.
*Self modding.
*Run in native python.
*Push stored stack to stack, to get list in list.
*Very heavy on the stack, functions take arguments from the stack, they can't take instructions/data from the grid directly.
*Basically Aaargh++!
*Complicated, not limited.
*Run by native python code.
==Specs==
*Planes are 80*80 and form dimension 1 and 2.
*The grid is an 2d grid of planes, and forms dimension 3 and 4.
*There is a main file, that's the one you need to execute. It defines the grid, but later on extra planes can be added.
===The main file===
*1d, kinda regular.
*Planes are loaded with lines like:
 0 0 plane1.txt
 1 0 plane2.txt
*There is no need for them to touch, but one can't use code in a plane that isn't touching any plane (unless you load a bridge plane from the program itself). There can be "holes" in the grid, they'll just give you an error if your cursor tries to enter it.
===Instructions===
Instruction	Description
d 	Set flow direction to d1, increasing ("right") This is the default flow direction.
a 	Set flow direction to d1, decreasing ("left").
s 	Set flow direction to d2, increasing ("down").
w 	Set flow direction to d2, decreasing ("up").
6 	Set flow direction to d3, increasing ("right").
4 	Set flow direction to d3, decreasing ("left").
2 	Set flow direction to d4, increasing ("down").
8 	Set flow direction to d4, decreasing ("up").
5 	If the first value at stack is 0, invert flow direction (d becomes a, etc.), and jump over the next instriction.
j 	Store (push) value of the cell above the current cell to stack.
J 	Store entire stack to cell above.
k 	Duplicate top value on stack.
K 	Delete top value off stack.
L 	Add value of the cell above the current cell to the value on top of the stack.
l 	Reduce the value on top of the stack by the value of the cell above.
; 	Fetch (pop) value from top of stack and store to cell above.
: 	Switch entire stack with cell above.
i 	Get single char and store it on top of stack.
I 	Get a set of chars and replace the stack by it.
o 	Print top value of stack.
O 	Print entire stack.
p 	Add plane to the grid. The first 2 values of the stack are the location of it in d3 and d4. The rest of the stack represents the name of the plane.
- 	Do nothing, and continue to next instruction.
==Notes==
What cell is above another cell depends on the flow direction. For example, when the flow direction is d1+ (the default), the cell above would be the first cell in the direction d2-. If it's d2-, the cell above is the first cell found in d3+. d4 loops to d1
Category:Multi-dimensional languages
Category:Unimplemented
Category:2012
Category:Languages
Ababab

== Syntax ==
a 	Increment pointer by 1.
aa 	Decrement pointer by 1.
b 	Next cell.
bb 	Previous cell.
ab 	Print current cell value as ASCII character.
aaa 	Multiply current cell and next cell.
aaaa 	Divide.
abbb 	Add.
abb 	Ask the user for an input.
aabb 	The users input.
abab()	If statement, if true then skip to next line.
== Examples ==
This prints "Hello world!"
1. a b a a bb aaa aaa aaa aaa aaa aaa a a a a a a a a ab
2. b b a a bb aaa aaa aaa aaa bb abbb aa aa aa ab
3. a a a a a a a ab ab a a a ab
4. b ab bb a a a a a a a a ab aa aa aa aa aa aa aa aa ab a a a ab
5. aa aa aa aa aa aa ab aa aa aa aa aa aa aa aa ab b a ab
Category:Languages
Category:Turing complete
Category:Turing tarpits
Category:Low-level
Abc

== Introduction ==
Abc is an Esolang inspired by the Alphabet.
There are 3 main values. The clv, cl and ptr. clv is what the current line contains and is what is printed to the screen on a newline, and is zeroed every newline. cl is exactly the same as the Brainfuck cell array, and ptr is the same as the Brainfuck pointer. 
=== Commands ===
==== Letters ====
Majuscule letters add to clv, miniscule take away from clv.
Letter	Value
A 	1
B 	2
C 	4
D 	8
E 	16
F 	32
G 	64
H 	128
Though the maximum value you can make by using only one of each letter is 255, the clv is not restricted, it can even go above Int-64 max. This is the same for the cl.
=== Other ===
Character(s)	Function
+ 	Push clv to cl[ptr]. This doesn't zero clv.
- 	Push cl[ptr] to clv. This doesn't zero cl[ptr].
> 	Increment ptr.
< 	Decrement ptr.
/ 	Set return point for \
\ 	Go to the matching /, no matter what.
[ 	If clv is not 0 carry on, otherwise move to matching ].
] 	If statement end.
? 	Set clv to the ordinal of a single byte input.
(newline) 	Print then zero clv.
{ 	Start comment.
} 	End comment.
! 	See (newline).
(pipe) 	Ignore next newline.
== Methods ==
Using the functions and letters provided, we can do most brainfuck things.
Brainfuck 	Abc
,[.,] 	/?!\
[-] 	/-a+!\
++++++++++[>+++<-]++.	DB+/[>-BA+<-a+][\]
+++[>+<-] 	BA+/[>-A+<-a+][\]
== Usability ==
=== Turing ===
According to my knowledge this is Turing complete.
=== IO/Files ===
Using cat one could use this to make an automated file read/write program.
Category:Languages Category:Cell-based