nyuuzyou/wikis huggingface dataset:
Gregor's Answer

Gregor's Answer is an unfinished esoteric programming language created by Tanner Swett in 2013.
== Syntax ==
 <inner-block> ::= [whitespace] {<statement> whitespace} [<final-statement>] [whitespace]
 <statement> ::= <L-var> <R-var> <R-var> | <L-var> <outer-block> | <L-var> "(" <R-var> ")" <outer-block>
 <final-statement> ::= <statement> | <R-var>
 <L-var> ::= letter
 <R-var> ::= letter | "!" | "@"
In the above, "whitespace" means one or more whitespace characters, and "letter" means a lowercase English letter. Whitespace cannot occur where it is not expressly permitted.
== Operation ==
Objects in Gregor's Answer have one method (which is a sequence of statements) and 26 instance variables, one denoted by each letter of the English alphabet. Each instance variable contains a reference, which points to an object, a job, or nothing. When an object is created, all of its instance variables contain references to nothing. References are mutable; a reference pointing to a job can mutate to point to anything else. Within an object's method, ! denotes a reference to the object ("self"), @ denotes the method's current argument, and each lowercase letter of the English alphabet denotes the corresponding instance variable.
The statement xyz creates a new pending job whose target reference is y and whose argument is z. (The target reference and the argument are determined at the time the job is created, not at the time it runs.) x then becomes a reference to the new job. The new job is eligible to execute whenever its target reference points to an object. When the new job is executed, its target object's method is executed ("target object" meaning the object that the target reference points to).
The statement x{...} creates a new object whose method is .... x then becomes a reference to the new object.
The statement x(y){...} creates a new pending job. x then becomes a reference to the new job. The new job also has a forced reference, which is y. The new job is eligible to execute whenever y points to an object. When the new job is executed, ... is executed, with letters denoting the same instance variables as in the surrounding code, and ! and @ denoting the same references. (This means that the new job can modify the object's instance variables.)
Finally, the statement x, which can only legally appear as the last statement in an inner block, causes all references which point to the current job to mutate to point to the referent of x.
Initially, there is exactly one job, which is eligible to execute. When this job is executed, the program's source code is executed. The operation of a program is as follows: An unspecified pending job which is eligible to execute is selected. This job ceases to be pending, and is executed. This repeats until there are no pending jobs that are eligible to execute.
Category:Languages Category:2013
Gregor Richards

Gregor Richards wrote 2L, FukYorBrane, ORK, and Glass, as well as the EgoBF suite of Brainfuck interpreters and compilers (in the file archive at https://github.com/graue/esofiles/tree/master/brainfuck/impl/), EgoBot and various software related to BF Joust.
==External resources==
*His home page, codu.org
Category:People
GridJSON

GridJSON is an esoteric language based on JSON as scope/function syntax.
Here is the link to the interpreter/environment.
The documentation will assume that this interpreter is used.
==Error handeling==
Some compile errors, like JSON formatting errors, will be listed in "data/games/yourgame.json - error log.txt".
If your game does not appear in the list of available games, look here.
Most other errors are in "data/debug.log".
==General Syntax==
The code is written inside JSON.
The comments "//" are only here to demonstrate the behavior, 
the actual file may not contain any comments!
 {
 "name": "ExampleGame", //The name of the game, purely visual
 "version": "0.1.0", //The version of the game, purely visual
 "settings": { //Settings that might be changed before starting (sliders (NUMBER) and checkboxes (FLAG)). No other types are accepted.
 "options":{
 "exampleOption": { //internal name
 "type": "NUMBER", //its a number (a slider in this case)
 "range": "0 16", //range of the slider
 "name": "Cool Option", //display name
 "index": 0, //index (y position in the options menu
 "value": 4 //default value (optional)
 },
 "flagOption": { //internal name
 "type": "FLAG", //its a number (a slider in this case)
 "name": "Yes/No", //display name
 "index": 1, //index (y position) in the options menu
 "value": true //default value (optional)
 }
 },
 "presets": [
 {
 "name": "Default", //display name
 "values": { //values of the preset. Not all settings have to be applied.
 "exampleOption": 4,
 "flagOption": false
 },
 "index": 3 //index (y position) in the options menu. continue after last option.
 }
 ]
 },
 "code":{
 "context":{ //currently only the chessboard size is defined here
 "board":{ //width and height of the chessboard
 "width": "width", //values 1 - 128 (included)accepted 
 "height": "exampleOption" //options may also be used for variable size
 }
 },
 "structures":{ //custom structs (like structs in c#/any other language that uses structs)
 "PLAYER":{ //struct called PLAYER
 "score": "NUMBER", //all variables
 "highScore": "NUMBER" 
 }
 },
 "globals":{ //all global variables
 "players": "LIST OF PLAYER"
 },
 "functions":{
 //see Functions
 }
 }
 }
==Naming convention and variables==
===Naming convention===
code part 	naming convention
variable type / struct 	MYTYPE
variable name 	myVariable
function 	MyFunction
Builtin Constants 	THECONSTANT
Builtin Commands / keyword	THECOMMANDORKEYWORD
===Variables===
type 	usage
NUMBER	int
FLAG 	bool
COLOR 	color enum
===Constants===
====Colors====
name 	value
RED 	#FF0000
PURPLE	#FF00FF
BLUE 	#0000FF
CYAN 	#00FFFF
GREEN 	#00FF00
YELLOW	#FFFF00
ORANGE	#FF8800
BLACK 	#000000
WHITE 	#FFFFFF
====Other====
Other constants are TRUE and FALSE, used for variables of type FLAG.
==Functions==
==Commands==
Category:Languages
GridRun

In GridRun instructions are laid out along paths on a grid and are read by HEAD(s) moving along those paths.
== History ==
When searching for a name, the first obvious idea was Grid, but that name was already taken, so Run wa added to represent the motion aspect of the execution. On first glance, there is some resemblence in functionality to GridScript but GridRun is intended for more compact and primarily visual representation.
Category:Languages
Category:2021
Category:Unknown computational class
Category:Unimplemented
Grocery List

This language by User:PuzzleHunter84 takes the form of a grocery list. Each food item does a certain function depending on the first letter of the item.
Letter	Function
a 	pops the top two values on the stack, adds them together and pops the result.
b 	brings the bottom stack value to the top.
c 	copies the top value of the stack on top of the stack.
d 	pops the top two values on the stack, divides the second-to-the-top into the top, and pushes the result rounding down if necesssary.
e 	ends a loop and rechecks the top value.
f 	flips the top two stack values so the top value becomes the second-to-top value and vice versa.
g 	pops the top two values, pushes 1 if the top value is greater than the second-to-top value and 0 otherwise.
h 	pops a value, takes the value mod 26, adds 1, finds the letter of the alphabet in that position, and executes the instruction of that letter.
i 	inputs a character and pushes it's ASCII value on top of the stack.
j 	pops the top value and jumps forward that many instructions.
k 	kills the stack, removing every value.
l 	opens a loop that runs if the top value is nonzero.
m 	pops the top two values on the stack, multiplies them together, and pushes the result.
n 	pushes a number onto the stack equal to the number of letters in this food item.
o 	pops the top value on the stack and outputs it as a numeral.
p 	pops the top value and prints it as an ASCII character.
q 	nop.
r 	pops the top two values on the stack, divides the second-to-the-top into the top, and pushes the remainder.
s 	pops the top two values on the stack, subtracts the second-to-the-top from the top, and pushes the result.
t 	terminates the program immediately.
u 	unbrings the top value to the bottom.
v 	take the next list item, does not execute it, and instead pushes the ASCII value of the first letter of the list item.
w 	pushes 100.
x 	pops the top value.
y 	pops the stack item that corresponds to the number of letters in this item.
z 	pops the top value, and pushes 1 if it is 0 and 0 otherwise.
Each program starts with a title that is the store name and is ignored such as: "Hello World Marketplace". Then there is an empty line before the list. Each item is seperated by a new line.
==Programs==
===Cat Program===
 Cat Groceryplace
 
 ice cream 
 lettuce
 popcorn
 imported bisque
 eggs
 tunafish
This is equivalent to the BF program: 
 ,[.,]
==Implementation==
An interpreter in Python 3 that tries to follow the specification above as closely as possible can be found here.
Another in hare can be found here, along with a modified version of the above Python version.
Category:Languages
Category:2009
Category:Stack-based
Category:Implemented
Category:Thematic
Groinfrick

== groinfrick ==
totally not a Brainfuck clone
== Commands ==
^	Set current pointer to corrosponding argument point
?	Echo current pointer
!	Echo current pointer's data
*	Exit prematurely
+	Add 1 to pointer selected
-	Remove 1 from pointer selected
<	Move to right pointer
>	Move to left pointer
Loop	Process
[, ]	While current pointer is not null
{, }	While current pointer is not string
(, )	While current pointer is not int
== Data Types ==
=== Strings ===
From 1 to 26 in the QWERTY alphabet.
=== Integers ===
From 26 to infinity - so 27 == 0, 28 == 1, 29 == 2, etc.
=== Null ===
When the pointer data is equal to 0.
== Interpreter ==
Made in JavaScript/Node, from the creator themselves: GitHub
Grow Tree

==Main==
Grow Tree is a language based off of cells.
Cells can be in any of 5 types: Cell, Input, Output, Modify, and Empty.
Cells have a genome. They specify the cell's behavior. The cell reads all the cells adjacent to it. When a cell's neighbors corresponds with a pattern in the genome, then it will grow into the cells specified. There are also merges, where a cell grows into another cell, they xor their genomes together then xor with another value specified by the programmer, and that's the genome used.
Inputs modify a cell by xoring it with a value specified by the programmer, but that value is one value if the input bit is 1, but another value if the input bit is 0. Also, the inputted string is inputted in order from the first bit to the last, and the order is in input cell activations.
Output is like input, but it only xors with 1 value, and it uses another set of values from the output cell to determine in order to output 1 or 0.
Modify is like output, but it doesn't output anything.
It's quite simple to prove this is Turing complete, since xors are Turing complete.
==Branches==
Before we talk about branches, we have to talk about active cells and inactive cells. Only active cells can grow, but once they have grown, they become inactive. Branches have a start and a end. A new branch is formed when either a older active cell grows multiple new cells, or when a cell's genome gets modified. (The cells in both cases are the start of the branch) 
When a branch's active cell either stops growing or gets blocked in all directions, the branch dies. When a branch dies, all its cells die and disappear into nothing.
==Programs==
There are no programs yet, but you can add your own.
Category:Languages
Category:Unimplemented
Grusom Skjebne

Grusom Skjebne (Norwegian: Cruel Fate) is an esoteric programming language written by User:5k17 in July 2010.
==Specification==
There are three memory cells which can hold integer values between 0 and 69105, with values exceeding these limits being wrapped; for some operations not the actual values, but their numbers transformed to a string matter. For these, there is a variable Z which specifies which digit is used as their argument.
Grusom Skjebne code consists of the digits 0-9, which each signify a certain operation; any other character is treated as an EOF sign.
*1 sets cell 0 to a random value.
*2 is a conditional statement: the next operation will only be performed if the value of cell 1 is greater than or equal to that of cell 2.
*3 subtracts the values of cells 1 and 2 and for a number of times equal to the absolute value of their difference, the initially lower one is increased by one, while the initially higher one is decreased by one. In addition, each time, the operation coded after the "3" is performed. If this is a "2", the condition must be met for one of the following digits in the code per run of the "3" loop.
*4 increases the value of Z by one. If Z is greater than the string length of the numeric value of cell 0, it is reset to 0.
*5 sets the value of cell 0 to its string length.
*6 outputs the Zth digit of the string of cell 0.
*7 outputs the ASCII character represented by the value of cell 0 mod 256.
*8 exchanges the values in the memory cells, so after the operation, cell 0 has the value of cell 1, cell 1 that of cell 2 and cell 2 that of cell 0.
*9 multiplies the value of each cell with that of the following one (cell 2 is multiplied by the value of cell 0).
*0 executes the command corresponding to the Zth digit of the string of cell 0. If that digit is 0, this command is ignored.
The commands 1, 5, 6, 8 and 9 also set Z to 0.
==External resources==
*Author's homepage
Category:LanguagesCategory:2010Category:Usability unknownCategory:ProbabilisticCategory:Implemented
Gtltem

gtltem (greater than, less than, exclamation mark) is an esoteric language created by username qwerty12302 in 2015. The language consists only of three characters: <, > and !, to which the name of the language refers.
==Memory==
The gtltem memory consists of seven bits, which can store exactly one gtltemASCII character. The value of this memory place can be changed using < or >, < decrementing and > incrementing it. The value of the memory is set to zero in the beginning.
==Syntax==
A gtltem program would look like this:
 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>!>!>!
Output:
 ABC
This program prints out the first three letters of the alphabet, located in decimal places 33, 34 and 35 in ASCII. The > increments the value of the memory (hereafter value) by 1 and ! prints the corresponding ASCII character.
==ASCII==
gtltem uses gtltemASCII, which is ASCII without control characters:
Code	Character
00 	
01 	!
02 	"
03 	#
04 	$
05 	%
06 	&
07 	'
08 	(
09 	)
10 	*
11 	
12 	,
13 	
14 	.
15 	/
16 	0
17 	1
18 	2
19 	3
20 	4
21 	5
22 	6
23 	7
24 	8
25 	9
26 	:
27 	;
28 	<
29 	=
30 	>
31 	?
32 	@
33 	A
34 	B
35 	C
36 	D
37 	E
38 	F
39 	G
40 	H
41 	I
42 	J
43 	K
44 	L
45 	M
46 	N
47 	O
48 	P
49 	Q
50 	R
51 	S
52 	T
53 	U
54 	V
55 	W
56 	X
57 	Y
58 	Z
59 	[
60 	\
61 	]
62 	^
63 	_
64 	`
65 	a
66 	b
67 	c
68 	d
69 	e
70 	f
71 	g
72 	h
73 	i
74 	j
75 	k
76 	l
77 	m
78 	n
79 	o
80 	p
81 	q
82 	r
83 	s
84 	t
85 	u
86 	v
87 	w
88 	x
89 	y
90 	z
91 	{
92 	
93 	
==Examples==
===Hello, World!===
This program prints “Hello, World!”:
 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>!>>>>>>>>>>>>>>>>>>>>>>>>>>>>>!>>>>>>>!!>>>!<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<!<<<<<<<<<<<<!>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>!>>>>>>>>>>>>>>>>>>>>>>>>!>>>!<<<<<<!<<<<<<<<!<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<!
==Implementation==
A simple implementation in Common Lisp shall follow:
 (declaim (type (simple-string 95) +GTLTEMASCII-CHARACTER-TABLE+))
 
 (defconstant +GTLTEMASCII-CHARACTER-TABLE+
 " !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~"
 "Maps gtltemASCII codes to characters.")
 
 (defun gtltemASCII-character-for (code)
 "Returns for the gtltemASCII CODE the matching character."
 (declare (type (integer 0 94) code))
 (the character (schar +GTLTEMASCII-CHARACTER-TABLE+ code)))
 
 (defun interpret-gtltem (code)
 "Interprets the piece of gtltem CODE and returns the NIL value."
 (declare (type string code))
 (let ((memory 0))
 (declare (type (unsigned-byte 7) memory))
 (loop for command of-type character across code do
 (case command
 (#\< (setf memory (mod (1- memory) 128)))
 (#\> (setf memory (mod (1+ memory) 128)))
 (#\! (write-char (gtltemASCII-character-for memory)))
 ((#\Space #\Tab #\Newline) NIL)
 (otherwise (error "Invalid command: ~s." command))))))
Category:Languages
Category:Total
Category:Implemented
Category:Unusable for programming
Category:Output only
Category:Low-level
Category:2015
Gudo

Gudo is Turing-complete 2-dimensional language.
===Commands===
Gudo consists of two commands ( / and @ ) and 5 classes. Every movement adds 1 to class.
 class 1:
 / reflect direction, set class to 0
 @ reflect to other way, set class to 0
 
 class 2:
 @ increment, class = 1
 / return point, class = 0
 
 class 3:
 / jump to topmost return point if cell is true, class = 0
 ends program if no return point
 @ decrement, class = 2
 
 class 4:
 / next cell, class = 3
 @ previous cell, class = 3
 
 class 5:
 / print cell, class = 3
 @ input cell, class = 3
===Brainfuck to Gudo===
Brainfuck can easily be converted to Gudo. I made converter with Perl.
 if (($#ARGV + 1) != 2) {
 print "Usage: perl bftogudo.pl input output\n";
 exit;
 }
 
 my $bf;
 open(I, "<", $ARGV[0]);
 
 while (<I>) {
 $bf = "$bf$_";
 }
 close(I);
 
 my $gudo = ;
 my $class = 1;
 my $dir = 0;
 
 while ($bf =~ /(.)/g) {
 if ($1 =~ /^\+$/) {
 $gudo = "$gudo @ ";
 }
 if ($1 =~ /^\-$/) {
 $gudo = "$gudo @ ";
 }
 if ($1 =~ /^\<$/) {
 $gudo = "$gudo @ ";
 }
 if ($1 =~ /^\>$/) {
 $gudo = "$gudo / ";
 }
 if ($1 =~ /^\[$/) {
 $gudo = "$gudo /";
 }
 if ($1 =~ /^\]$/) {
 $gudo = "$gudo /";
 }
 if ($1 =~ /^\.$/) {
 $gudo = "$gudo / ";
 }
 if ($1 =~ /^\,$/) {
 $gudo = "$gudo @ ";
 }
 }
 $gudo = "$gudo /";
 
 print $gudo;
 
 open(TARGET, ">", $ARGV[1]);
 print TARGET $gudo;
 close(TARGET);
Guh

guh was a joke esoteric programing language inspierd by a screenshot made in the Progresscord Development discord server and chicken
== Commands ==
Number of guh's	Meaning
0 	Start executing the next command
1 	Pushes a character (or a character array) into a stack.
2 	Outputs the highest value on the stack.
3 	Input.
4 	Makes a variable
5 	Makes a loop of a code, works like this:
guhguhguhguhguh
*command, use square brackets if you need to combine more commands*
*amount of repeats*
6 	Condition command, works like this:
guhguhguhguhguhguh
*variable name*
*something to check if equal*
7 	
8 or higher 	Marked as comments
==Other variants==
===tab===
tab is a variant of guh which uses a character table. To edit it, you just do this
 hi!
simple really, the character table doesn't change if you put the "execute the next command" instruction.
Also instead of pushing characters to the stack, you instead push character table indexes in "tab"
== Examples ==
=== Hello World ===
====guh====
the space is represented as "_"
guh d l r o W _ o l l e H
guhguhguhguhguh
guhguh
11
====tab====
 Helo Wrd
 guh 7 2 6 3 5 4 3 2 2 1 0
 
 guhguhguhguhguh
 guhguh
 11
Category:LanguagesCategory:2024Category: Stack-based
Gulf

Gulf is yet another code-golfing language, but unlike many existing ones it is not truly stack-based. Gulf makes use of postfix, infix and prefix operators using an annotation system instead of parentheses. An infix expression is denoted by a comma and a postfix expression by a dot. Therefore +.,5+5+ would be +((5+5)+) in a system using parentheses. The author of this programming language is User:Feuermonster which roughly implies that this will be yet another complicated/bloated programming language just like Burlesque.
== Examples ==
gulf) ,:4M{~:p
[[1] [2 1] [3 2 1] [4 3 2 1]]
gulf) ,,5+,3*3*_1
-14
== External resources ==
Source-Code Repository
Category:Languages
Category:Golfing language
Gulp

Gulp is an esoteric programming language made by Areallycoolusername. It was made for golfing, and it is deque-based
== Specifics ==
Gulp uses 128 commands to allow for a wide range of functions. By doing this, many programs have been made to be shorter than programs of the same function in different golfing languages.
== External Resources ==
Further documentation may be found here.
Category: 2019
Category: Golfing language
Category: Deque-based
Category:Languages
H

:Note that h is typically lowercased.
h is a programming language created by Nerdaxe#9443 which is extremely limited.
Every program is an arbitrarily long but finite list of unbounded integers, separated by commas. The accumulator and index of the current cell are set to 0 initially; cells are 0-indexed.
Say that the accumulator is A, the index of the cell being pointed to by the IP is C and i(n) is the value of the nth cell. The operation order:
* A is set to i(i(C)) - A
* i(i(C)) = A
* if A is negative, C becomes i(C+1), otherwise C becomes C+2
Execution ends when the instruction pointer goes to an index larger or smaller than the largest/smallest index in the list, respectively.
==Sample programs==
20,2,19,4,7,6,7,0,19,10,21,12,15,14,15,0,18,-1,-1,0,A,0
A is a placeholder for any integer. This program will eventually print
20,2,19,4,7,6,7,0,19,10,21,12,15,14,15,0,18,-1,-1,-A,A,A
===Hello, World!===
A strict version of the Hello, World! program is technically impossible, because all output is a list of numbers.
===Infinite Loop===
8,2,9,4,9,6,8,2,-1,0
By VilgotanL, explanation using pseudo-code similar to subleq assembler:
neg1 2 #acc is now -1
zero 4 #acc is now 1, the variable zero is 1
zero 6 #acc is now 0, the variable zero is 0
neg1 2 #acc is now -1, go back to 2
neg1:-1 zero:0 #variables
===Quine===
1,-1
==Computational class==
The computational class of h is unknown. A variant, h2, was created by User:Andrew3335 in the hopes of being a suitable Turing-complete replacement if h itself is not turing complete. The only deviance from h in h2 is that the list of integers that serves as the initial program is assumed to have an infinite amount of 0s appended to its end, such that the only way to end execution is now for the instruction pointer to go to a cell whose index is smaller than 0.
==Implementation==
a=0
p=0
m=[]
while -1
Heavily golfed Python 3 program by Nerdaxe.
Category:Languages
Category:Unknown computational class
Category:2021
Category:Implemented
Category:Low-level
Category:OISC
Category:Cell-based
H+Q9

H+Q9 is a derivative of HQ9+ invented by User:None1. The characters are the same while the meanings of the characters are different.
H: Halt.
Q: Quit.
9: Output next character 9 times and halt.
+: Output next character once and halt.
==Examples==
===Quine===
 999999999
======
 +4
===NOP===
 Q
or
 H
or simply
===Screamer (only for 9 times)===
 9A
prints
 AAAAAAAAA
===Cheating Hello, world!===
 +問+天+地+好+在H
=== Screamer(more times) ===
 9A 9A 9A 9A 9A 9A 9A 9A 9A 9A 9A 9A 9A 9A 9A 9A 9A 9A 9A 9A 9A 9A 9A 9A 9A 9A 9A 9A 9A 9A 9A 9A 9A 9A 9A 9A 9A 9A 9A 9A 9A 9A 9A 9A 9A 9A 9A 9A
==Notice==
After creating this esolang, the author noticed that it isn't that useless after all. The esolang supports printing any character once or 9 times, allowing more powerful programs than HQ9+.
==Interpreter==
===C===
#include<stdio.h>
int main(){
 char c=getchar();
 if(c=='9'){
 c=getchar();
 printf("%c%c%c%c%c%c%c%c%c",c,c,c,c,c,c,c,c,c);
 }else if(c=='+') putchar(getchar());
 return 0;
}
Try it online!
Category:2023
Category:Implemented
H9+

H9+ is HQ9+ with two differences: there is no "Q" instruction, and all characters that are not H, h, 9 or + are explicitly ignored. "hello, world" is therefore a quine.
==Interpreter==
Written in ES6 JavaScript. 288 bytes. Pass the code, don't pass a.
 var hqplus=(c,a=0)=>c.map(h=>{(h=="H"||h=="h")&&alert("hello, world");h=="9"&&(()=>{for(x=99,z=(a=' on the wall')=>`${x||99} bottle${1-x?'s':''} of beer`+a;x;)alert(z()+', '+z`.`+(--x?'Take one down and pass it around, ':'Go to the store and buy some more, ')+z()+'.')})();h=="+"&&a++;});
Category:Languages
Category:Joke languages
Category:Unusable for programming
Category:Total
Category:Implemented