nyuuzyou/wikis huggingface dataset:
Graphical Brainfuck

Graphical Brainfuck (GBF) is a esoteric programming language created by juju2143 in Febuary 2017. It is a multi-dimensional extension of Brainfuck that maps each triad of cells to a graphical screen.
== Language overview ==
What would be the tape in normal Brainfuck is a three-dimensional 320x240 array of pixels matching the size of a graphical display, each pixel containing 3 cells for each of the three RGB color components. The programs start at (0,0,R), the commands are mostly the same as in Brainfuck, with the > and < commands moving the pointer along the cells on the X-axis, the R cell of the next pixel going after the B cell and vice-versa, wrapping back to the beginning or the end of the line in a circular fashion. + and - similarly wraps around when 0 or 255 are reached.
To move between the lines, GBF introduces an additional command, @, which flips between horizontal and vertical modes. In vertical mode, < moves up along the Y-axis instead of left, likewise for > which moves to the pixel below's R cell instead of the right pixel's when the pointer is on a B cell.
GBF does not change the color of the display by itself, instead the . command is used to send each of the three RGB cells of the current pixel at the current pointer position on the screen. In the reference implementation, ! is used to wait for a key, but the value isn't written to the cell like , does.
The language can be adapted to run with screen of any size than 320x240 and cells going up to other values than 255 to accomodate for other color spaces such as RGB565 (R and B goes up to 31, G goes up to 63), CMYK (which would require 4 cells/pixel instead of 3 going from 0 to 100) and HSL (H goes from 0 to 359 and S and L goes from 0 to 100), or even monochrome (probably more akin normal brainfuck at this point with a single bit/pixel and + ends up doing the same thing as - as bit flippers, @ may still be useful). If the screen is unbounded, the language should be Turing-complete.
== Commands ==
Command	Description
> 	Move the pointer to the cell to the right in horizontal mode or down in vertical mode
< 	Move the pointer to the cell to the left in horizontal mode or up in vertical mode
+ 	Increment the memory cell under the pointer
- 	Decrement the memory cell under the pointer
. 	Output the pixel the cell at the pointer is part of at the current pointer position on the screen
, 	Waits for key input and store the character in the cell at the pointer, mod the maximum capacity of that cell
[ 	Jump past the matching ] if the cell under the pointer is 0
] 	Jump back to the matching [ if the cell under the pointer is nonzero
@ 	Flips between horizontal and vertical modes
! 	Waits for key input, but discards it (optional)
== Examples ==
=== Paints screen white ===
 +[[--.>+]@>>>@+]
== Implementations ==
* razetime/graphical-bf: Supports all commands. Infinite canvas(Down and left), RGB, single byte cells, character-by character input. Github
Category:Languages
Category:Turing complete
Category:Turing tarpits
Category:Cell-based
Category:Multi-dimensional languages
Category:Brainfuck derivatives
Category:Implemented
Category:2017
Category:Graphical Output
Graphwalk

Graphwalk is an esoteric programming language based on a graph.
==Syntax==
The syntax is really symple: it's just a graph.
the precise format:
N S
action1 D1 B1,1 ... B1,D1
action2 D2 B2,1 ... B2,D2
...
actionN DN BN,1 ... BN,DN
That is, first comes the total number of nodes and the starting node, then one line for each node containing the action to do and the nodes to go to.
for example:
4 1
` 3 1 4 2
` 2 2 1
+2 1 4
` 3 0 2 3
means the graph
==Actions==
let X be the current node, starts at S.
each node has a internal counter, which starts at 0.
going out of bounds will halt.
the process is: 
* do the action stated
* compute the counter's value modulo DX, and call it A
* increment the counter
* go to BX,A.
the actions:
 actions
action	meaning
+x 	add node x's counter by 1
p 	prints the current node's counter value modulo 256 as a character
n 	prints the current node's counter value as number
` 	NOP (operation)
?x>y 	TBD
==Computational class==
It is of course a Finite-state machine.
Category:Finite state automataCategory:2024Category:Declarative paradigmCategory:LanguagesCategory:Output only
Grasp

Grasp is a graph-oriented esolang; there are far too few of them so far.
Designed by User:Fizzie in 2010, then redesigned in 2014, and possibly there were some iterations in-between, too.
The main concept of Grasp is that the code (and data) is a directed multigraph (multidigraph) labeled nodes and edges.
It is this mostly superficial similarity to Lisp (w.r.t. the "code and data both are lists" thing) that was an inspiration for the name.
The name is an abbreviation of "GRAphS are being Processed".
== Summary of the specification ==
Grasp scalar values (node labels) are either (double-precision floating point) numbers or strings; edge labels are always strings.
More complicated data structures are built as subgraphs.
Singly linked lists connected by next edges is used to for stacks and (non-constant) strings by the instruction set.
A running Grasp system has a list of IPs that contain a call stack that refer to nodes in the graph.
At each "tick", the list of IPs is processed, and the current node of each IP is interpreted as a command and executed.
After the execution, a next edge is followed to find the new current node.
Edges labeled cond can be used for conditional execution, and edges labeled name assign names to nodes.
The instruction set provides instructions for manipulating the graph, as well as for doing simple arithmetics and IO.
Control structures are built by adjusting the next edges, possibly conditionally.
For further details, see the full specification.
== Example programs ==
=== cat ===
(This program was written against an old version of the spec; the "adde" and "dele" instructions should be "new" and "del" now.)
The "getc" node reads a single character and stores in the node (initially) containing "c".
The "add" node increments the value by one, so that an EOF value (-1) becomes zero.
The "dele" node unconditionally clears any next edge of the "adde" node, and the "adde" node adds it back if the "c+1" node contains a nonzero value, i.e., if EOF was not read.
The "putc" node writes the character, and the loop continues.
== Reference implementation ==
Work in progress.
== External resources ==
* Full specification
* Interpreter in Haskell using the DOT graph description language for the file format
Category:2010Category:LanguagesCategory:Non-textualCategory:Self-modifying
Grass

Grass is a functional grass-planting programming language. Its unique characteristic is that it is said to be easy to slip into ASCII art.
Grass is based on lambda calculus, and the program consists of a list of abstractions and applications of functions, using only the characters W, w, and v.
== Overview ==
The following six characters are valid characters for Grass, and others are ignored：W, w, v, ｗ, ｗ, and ｖ. The three full-width characters are semantically identical to each corresponding half-width character.
A program in Grass is considered to be a sequence of functions.
Tokens beginning with W are application and those beginning with w are abstraction. v separates tokens.
Grass has a SECD machine as a virtual machine.
Its environment is initialized with four primitive functions: Out, Succ, integer 119 (or character 'w'), and In.
The Out function takes one argument, an integer, to output it as an ASCII character. It must be an integer or else the program will abort.
The Succ function takes one argument, an integer n, to return (n+1) \% 256.
Integer can be both an argument of a function and a function itself. As a function, it takes one argument to return if the integer value and that of its argument are equal, as a Church boolean (\lambda xy.x and \lambda xy.y for true and false respectively).
The In function takes one argument, reads a character from stdin, and returns it on success or returns the argument instead if EOF is encountered.
== Examples ==
The following code prints a single 'w'.
wWWwwww
The following code prints 'w' forever.
無限に草植えときますねｗＷＷｗｗｗｗＷＷｗｗ
The following code calculates 1+1 and prints the result as a number of 'w's.
wwWWwv
wwwwWWWwwWwwWWWWWWwwwwWwwv
wWWwwwWwwwwWwwwwwwWwwwwwwwww
== External resources ==
* http://www.blue.sky.or.jp/grass/
Category:Languages
Category:Functional paradigm
Category:Implemented
Category:2006
Gravbox

Gravbox is a stack based 2 dimensional esolang with a concept of gravity created by User:Moon. It started as a reversible language (see Billiard_ball_machine)
:Note: this language is still something of a work in progress. If I ever try to implement it, I may end up changing some details to make doing so easier.
Gravbox uses one thing, a Ball ('), as the starting point on the program. you can have as many Balls as you want ,they will all move at the same time under the effect of gravity, running the commands they move onto. Gravity can be switched using a switcher (@), going counter-clockwise. the stack always starts with a single 0 and has no bounds on number size
== Commands ==
* `@`: Switch the direction of gravity counter-clockwise, affecting all balls.
* `/`: A right pointing deflector, sends the ball to the side.
* `\`: A left pointing deflector, sends the ball to the side.
* `!`: invert the value of the first item on the stack, then push it back ( n(-1) )
* `0-9`: pushes the respective value to the stack.
* `+`: adds together the first two values on the stack, pushes the result
* `-`: subtracts the first value from the second value on the stack, pushes the result
* `*`: multiplies the first two values on the stack and pushes the result
* `|`: divides the first value from the second value on the stack and pushes the result
* `,`: pushes input to the stack.
* `.`: outputs the first value on the stack, and removes it permanently
* `^`: duplicates a value on the stack.
* `#`: Wall, stops balls in their tracks until the gravity changes and allows them to slide off
* `%`: cuts a value from the stack; delete
* `a-z & A-Z`: pushes their respective letter (With capitalization) to the stack.
* `?`: Random deflector, randomly acts as either \ or /
* `&`: / if first value on stack is larger than 0, else \
* `$`: pushes the amount of values on the stack to the stack.
* `~`: abort program.
* `:`: swap the top and bottom of the stack
== Sample programs ==
Hello, World! using ASCII character set
 
 ‘
 @92+3*dlroW84*92+4*olleH...............~
== Trivia ==
1. By removing + - * | , . % ? & $ a-z/A-Z and 0-9, the language is entirely reversible
Category:2016
Category:Two-dimensional languages
Category:Implemented
Category:Stack-based
Category:Languages
Graverage

Graverage is an automaton/esolang designed by User:Challenger5.
=== Program Structure ===
A Graverage program consists of:
* A set of one or more objects, called points.
* A mapping from each point to a pair of rational numbers, called its initial coordinates.
* A mapping from each point to a bag of one or more points (including itself), called its neighbors.
* A sequence of points (the instruction list), which is assumed to repeat infinitely.
=== Execution ===
Points from the instruction list are executed by updating their position to the average position of their neighbors. Neighbors are weighted by how many times they appear in the bag.
=== Syntax ===
Interpreters can use any syntax, but the reference interpreter (were one to exist) works by getting all numbers from the digit string and interpreting them as follows:
* The first number, which we’ll call N, defines the number of points (which are identified by integers from 0 to N-1).
* Define the initial coordinate and neighbor arrays by repeating the following N times:
** Read four integers. The first two are treated as the numerator and denominator of the initial x-coordinate, and the last two are treated as that of the initial y-coordinate.
** Read a nonnegative integer M. The next M integers (which must be between 0 and N-1) are interpreted as identifiers for the point’s neighbors.
* The remaining integers (which must be between 0 and N-1) comprise the instruction list.
=== Computational Class ===
No clue.
=== Examples ===
PyGraverage
3 1 1 0 1 3 1 2 2 -1 1 0 1 3 2 3 3 0 1 1 1 3 3 1 1 1 2 3
Exec depth 1- 1:(-0.33, 0.0), 2: (-0.33, 0.66), 3: (-0.22, 0.33)
Exec depth 2- 1: (-0.33, 0.44), 2: (-0.2594, 0.444), 3: (-0.296, 0.407)
4 1 1 1 2 4 0 1 3 2 1 1 0 1 3 0 2 1 -1 1 0 1 3 1 2 2 0 1 1 1 3 2 0 0 0 1 2 3
Exec depth: 3
=== Interpreter ===
A python-based interpreter: 
* This particular interpreter uses the reference syntax, with the exception that points are numbered in the instruction list starting from 1 instead of 0. It also has a finite execution depth, that is, it only runs the instruction list for a finite, specifiable number of times.
* It expects the program to be a single line of integers. Any other lines will be ignored
A slightly better interpreter, with graphical output and a nicer user experience: 
*This version can show the trajectories of the points aver multiple iterations.
Category:Languages Category:Unknown computational class
Gravilang

Gravilang is an programing language so small that it can run on literal balls (i am actually trying to do that btw using Gravitrax), while still being able to to conditions (not necesarelly turing complete because it cannot do nested conditions). It has 2 registers that can store 2 bits, in other words an number between 0 and 3. All the registers start at 0. Each program happens on two rows, called = and ≠. The pointer starts in the = row, and after each command it moves 1 collum to the right. The commands can change the lane before executing the next command. If it reaches the end it will loop back at the first collum, while preserving the row. The avaliable commands are:
*A (A+): Adds 1 to the first register. Normally it switches to the ≠ row but if after incrementing it loops back to 0 then it switches to =
*B (B+): Adds 1 to the second register. The same incrementing row rules applies.
*N (NOP): Doesn't do anything and switches to the = row. Useful for conditions
*O (OA): Ouputs a point (because I dont have enough pieces for the balls to ouput diferent values but i do have to just ouput a single ball with no extra context) and increments A. The same incrementing row rules applies.
*H (HALT): Self explanatory
==Notes==
In a single collum you cant put both of the commands B N or O H, but you can put both of B O, B H, N O or N H.
=Programs=
*"Truth machine" (The input is stored at start in the second register (B). If 0 ouputs and halts, if 1 ouputs forever) (= and ≠ are just to show the rows):
 =|OBBBBH
 ≠|OBBBBN
*4-bit Counter (Before looping the first register represents the 4,8 bits and the second the 1,2 bits after incrementing):
 =|BA
 ≠|BN
Category:Languages Category:2024 Category:Unimplemented Category:Unknown computational class
GravitaSumma

gravitaSumma (from Latin gravitas summa meaning intense gravity) is a simple programming language created in 2020 by user:threesodas in order to show how order of objects can be applied to programming languages.
 (x, y) fnt add [
 x + y = int z;
 (z) print;
 ]
This page is a work in progress....
Category:Languages Category:2020
Gravity

Gravity was invented by Safalra (Stephen Morley) on 4th August 2005, based on a idea from Isaac Newton. Gravity is very different from any other existing programming language. Although its behavior is well-defined and deterministic, the evolution of its space is in general non-computable, due to the nature of the differential equations that govern it.
==Introduction==
The execution of a Gravity program consists of the simulation of the effects of gravity on a countably infinite number of point particles. The initial space configuration is an infinite two-dimensional grid of point particles positioned with one at every point (x,y), where x and y are integers, with all but a finite number of unit mass. When particles collide they are replaced according to a set of collision rules specified by the program. Input, output, and halting can happen only when collisions occur. It can be shown that a Turing machine cannot compute, in the general case, whether even a single collision will ever happen.
==Examples==
The language specification states that "comments are not permitted, but each program should ideally be accompanied by a mathematical paper offering a proof that the program behaves in the desired way." The examples below do not include proofs, but these can be found under "External resources".
===Hello World program===
The following code is a Gravity Hello, world! program. It outputs ASCII values corresponding to the phrase "Hello world", and then, assuming no input was provided, it halts.
 (0,0) : 2
 
 (1,1,1,1, 2) -> 3 : 72
 (1,1,1,1, 3) -> 4 : 101
 (1,1,1,1, 4) -> 5 : 108
 (1,1,1,1, 5) -> 6 : 108
 (1,1,1,1, 6) -> 7 : 111
 (1,1,1,1, 7) -> 8 : 32
 (1,1,1,1, 8) -> 9 : 119
 (1,1,1,1, 9) -> 10 : 111
 (1,1,1,1,10) -> 11 : 114
 (1,1,1,1,11) -> 12 : 108
 (1,1,1,1,12) -> # : 100
===Cat program===
The following code is a cat program. The encoding used can be any encoding that maps characters to a series of 3s and 4s (for example, mapping characters to their Unicode positions, and then turning 0 and 1 bits into 3s and 4s respectively).
 (0,0) : 2
 
 (1,1,1,1,2) -> # :
 (1,1,1,1,3) -> # : 3
 (1,1,1,1,4) -> # : 4
===Digital root program===
The following code is the first few lines of a digital root program. The program works with the standard ASCII encoding of the digits 0 to 9. The full program is 113 lines long.
 (0,0) : 2
 
 (1,1,1,1, 2) -> # :
 (1,1,1,1,48) -> # : 48
 (1,1,1,1,49) -> # : 49
 (1,1,1,1,50) -> # : 50
 (1,1,1,1,51) -> # : 51
 (1,1,1,1,52) -> # : 52
 (1,1,1,1,53) -> # : 53
 (1,1,1,1,54) -> # : 54
 (1,1,1,1,55) -> # : 55
 (1,1,1,1,56) -> # : 56
 (1,1,1,1,57) -> # : 57
 (1,1,1,1,48) 48 -> 48 :
 (1,1,1,1,48) 49 -> 49 :
==External resources==
* , with examples and proofs
Category: Languages
Category: 2005
Category: Usability unknown
Category: Unknown computational class
Category: Two-dimensional languages
Category: Unimplemented
Category: Low-level
Category: Uncomputable
Grawlix

This is the horrible Grawlix Programming Language - created by User:DMC with the intent of introducing enhancements to brainfuck that still uphold it's spirit.
grawlix – Cartoonist's term for random symbols and punctuation used to represent swearing.
==Description==
*8 bit memory cells (or other bit amounts)
*Everything initialized to zero
*Cell values rollover
*Program memory infinite
*Data memory infinite
*Stack memory infinite
*T - top of stack
*P - data pointer
*(P) - byte value at P
*P < 0 is an error and should halt the program
*Pop when T = 0 is an error and should halt the program
*A program with only > < + - , . [ ] is Brainfuck, not Grawlix
*The Grawlix interpreter can be used as a Brainfuck interpreter
*Turing complete: yes, because Brainfuck is Turing complete
==Enhancements to brainfuck==
*Stack operations
*Decimal I/O
*Another loop structure
*Multiply / divide by two
*Functions
==Functions==
*Function definition '{ code }' can be anywhere in the program listing
*Function definition in program listing '{' is skipped to command after matching '}'
*Only function call '@' runs function code
*To call a function: push function number onto stack, call function with '@'
*The function number is determined by program parsing in the order it is encountered, starting with zero
*256 functions allowed
==Program parsing==
*Bracket integrity check
*Parenthesis integrity check
*Brace integrity check
*Tabulate open/close brackets
*Tabulate open/close parenthesis
*Tabulate function locations
==Brainfuck commands==
 ><+-,.[] 
==Grawlix Commands==
Command	Description
: 	Push (P)
; 	Pop (P)
? 	(P) = input decimal number mod 256
( 	Proceed to next command after ‘(‘ if (P) == 0, the opposite of brainfuck
) 	Return to matching '('
{ 	Begin function definition
==Some possible code constructs==
Code schematic 	Explanation
____ 	some code
{_______} 	a function definition
{___@___} 	a function call inside a function definition
{_____}__{________}___ 	two function definitions
{___{____}__} 	possible but unnecessary function definitions
__{_0__}__{__1__}{_2__}	
__[___]_(_____)__ 	loops
__[___(___]___)__ 	a possible loop structure, not a syntax error, unknown if it can be made to do something useful
==Examples==
===Hello World!\n===
 +|||+|||.>+++|||+||+.+++++++..+++.>+|||
 ||.>+|||+++|||-.<<.+++.------.--------.
 >+.>>+||+|.
===Fibonacci===
correct until an 8-bit rollover occurs
 >>+||+|<+<=>[>.<=:<[>+<-];>]!
===Truth-machine===
 :+:?(;;=^);[=]
==External resources==
*Grawlix Programming Language – Interpreter written in Python 3
Category:Languages
Category:Brainfuck derivatives
Category:Cell-based
Category:Implemented
Category:Turing complete
Category:Low-level
Category: 2017
GreeeeeeeeenText

GreeeeeeeeenText is a joke language being worked on by User:Areallycoolusername. All code is in the format of 4chans greentext memes.
A hello world program looks like:
>be me
>says Hello world!
>*gets output*
A compiler where all code actually turns green is being worked on. (But maybe blue instead for copyright and stuff.)
Category:2018
Category:Joke languages
GreekVM

GreekVM or GVM (though the former should be used to avoid confusion with the Groovy Virtual Machine) is a Virtual Machine/Instruction Set Architecture based on Geometry.
== Memory ==
The GreekVM's memory is stored as an infinitely large (obviously limited by implementation) array of 64-bit registers. Each register represents a point in 2-space, with bits 0-32 representing the x and bits 33-64 the y.
== Instructions ==
All instructions are performed on lines and points in the GreekVM's memory (excluding files, of course). This instructions are:
 (Note to self: Fill this space)
GreenBerry

greenBerry is a one line statement language created by Abdur-rahmaan Janhangeer as an in-shell utility for Python programs.
== Commands ==
Examples:
 var x = 1
 class Man : power = 10 action walk : print walking...
== File extension ==
.gb
== External resources ==
*Site
*Docs
*GitHub
Category:Languages
Category:Object-oriented paradigm
Category:Implemented
Category:High-level
Greentext

Greentext is a work-in-progress esoteric scripting language based off of the trademark greentext format (or "Meme Arrows") of the anonymous forum site 4chan. Every line in the language begins with a >.
==A Basic Rundown==
===Booleans===
 :^) = true
 :^( = false
===Printing===
 >mfw "Hello World!"
===Variable assignment===
 >be foo # Declare unassigned variable "foo"
 >be bar like 1234 # Dclare variable "bar" and assign it the value 1234
===If Statements===
 >implying foo is bar # if "foo" is equal to "bar"
 >mfw "True"
 >Or not # else
 >mfw "False"
 >done implying
("else if" statements have not been implemented as of November 12, 2015)
===For Loops===
 >inb4 i from 10 to 0 by -2 # Variable decrement variable i from 10 to 0 with step counter -2
 >mfw i # Prints 10, 8, 6, 4, 2 on separate lines 
 >done inb4 
===Main Function===
 >dank memes # Main function
 #Code n stuff
 >tfw # Return
===Function Declaration===
 >wewlad foobar (n,m) # Declare function
 >be barfoo like n + m # Define variable "barfoo"
 >tfw barfoo # Return barfoo
===Function Usage===
 >wew foobar(2,3) # wew is an internal variable that contains the value returned by the last function used.
 >be baw like wew # Assign the value in "wew" to "baw"
 >mfw baw # 5
==Examples==
===Fizzbuzz===
 >dank memes
 >inb4 i from 0 to 100 by 1
 >implying i % 15 is 0
 >mfw "fizzbuzz", i
 >or not
 >implying i % 3 is 0
 >mfw "fizz", i
 >done implying
 >implying i % 5 is 0
 >mfw "buzz", i
 >done implying
 >done implying
 >done inb4
 >tfw
===Fibonacci sequence===
 >wewlad factorial(n)
 >be result like 1
 >implying n > 1
 >be m like n - 1
 >wew factorial(m)
 >be result like wew
 >done implying
 >tfw n * r
 
 >dank memes
 >be n like 10
 >wew factorial(n)
 >mfw wew # Outputs n!
 >tfw
Category:Thematic
Category:Languages
Category:2015
Category:Unimplemented