nyuuzyou/wikis huggingface dataset:
Fuzzy Brainfuck

Fuzzy Brainfuck is an extension of Brainfuck inspired by the success of recurrent neural networks. It is a programming language with a continuous program space and its interpreter is end-to-end differentiable and compatible with normal Brainfuck program, specifically the 8-bit wrap-around dialect. It is meant to be a proof-of-concept for differentiable programming language.
The interpreter being differentiable allows training of programs with gradient-based methods.
The language is directly inspired by Neural turing machines. The difference is that neural turing machines have black-box neural network controller, meanwhile, Fuzzy brainfuck has an explicit instruction set.
==Interpreter==
Here's an implementation of Fuzzy brainfuck in Tensorflow: https://github.com/Py10lolz/Fuzzy-Brainfuck.
==Inner Workings==
In Fuzzy Brainfuck, instructions are probability distribution over Brainfuck's instruction set. Bytes are replaced by probability distribution over all the possible 256 values and this change applies input, memory, and output.
How these instructions influence input, output, memory, and the instruction flow are better explained at https://github.com/Py10lolz/Fuzzy-Brainfuck/blob/main/INNERWORKINGS.md.
In summary, Fuzzy brainfuck softens a binary circuit Brainfuck interpreter with cannonical softening of boolean operations: NOT(x) = 1-x, AND(x, y) = xy, and OR(x, y) = 1-(1-x)(1-y).
Category:Turing complete
Category:Brainfuck derivatives
Category:Languages
Category:2024
Category:Implemented
Category:Cell-based
F²

F² is an esoteric programming language made by User:AmNow. F² resembles Rubik’s cube notation.
== Commands ==
The data is stored on a cube net.
 L##
 ###
 ###
 F##U##B##D##
 ####*#######
 ############
 R##
 ###
 ###
 
 #: Data *: Data pointer starting point
U,D,L,R will move the data pointer on a side, looping around.
U2,D2,L2,R2 will move the data pointer around the sides.
U’,D’,L’,R’ will increment by 17, decrement by 2, double, or divide by 2 respectively.
F,B,F2,B2 will input as a character, output as a character, input as a number and output as a number respectively.
F’ and B’ act as BF’s [ and ] respectively.
== Programs ==
=== Spam #s ===
 U’ U’ D’ D’ D’ D’ D’ D’ U’ D’ D’ F’ B B’
== Computational Class ==
Due to the fact that F² has only 54 cells of memory, F² is not Turing Complete and is rather a Bounded-storage machine (BSM).
Category:2021Category:Bounded-storage machineCategory:LanguagesCategory:Unimplemented
Fünke

Fünke, named after Tobias Fünke of Arrested Development, is an esoteric programming language made to be almost entirely function calls. There are very few basic functions:
 Print:
 $(a) (Prints a)
 Basic math operators:
 +(a,b)
 -(a,b)
 etc...
 If statements:
 =(a,b,c,d...) (if a and b are equal, do c, d, etc...)
 >(a,b,c,d...) (same as above but with less than)
 <(a,b,c,d...) (same as above but with greater than)
 !(a,b,c,d...) (same as above but with not equal)
 Random #'s
 @(a,b) (Returns a random number between a and b)
Also, # is the input
== Making programs in Fünke ==
Programs are mainly written as definitions of functions. For instance,
 loop(a) = loop(a)
would keep looping. Similarly, you can make the loop do something. An example would be
 loop(a) = loop(a),@(0,a)
which would generate random numbers less than a. You can also declare things inside of functions, such as
 loop(a) = loop(a),a = @(0,a)
which keeps generating smaller numbers
== Example Programs ==
=== Cat Program ===
 $(#)
This just outputs the input
=== Fibonacci Generator ===
 fib(a,b) = $(a),c = +(a,b),b = a,a = c
 loop(a,b) = fib(a,b),loop(a,b)
 loop(1,0)
=== Guess the Number ===
 loop(a,b) = =(a,b,loop(a,b),run(a))
 run(a) = >(#,a,$("Too big!")),<(#,a,$("Too small!")),=(#,a,$("You win!"),b = a,new())
 new() = loop(@(0,100),-1),$("New Game!")
 new()
== See also ==
*Functional
Category:Languages Category:2014 Category:Functional paradigm Category:Unimplemented
G*

G* is an esoteric programming language made by User:M654z in 2015. G* was originally designed for code golfing.
===Commands===
 p - Prints text
 q - Creates a quine
 l - Loops commands a certain amount of times
 # - Everything after this symbol is ignored (a comment)
 ? - Asks for user input and stores it in a variable (1-9)
 @ - Prints a variable
 ` - Creates an infinite loop
 . - Sleeps for 2 seconds
 p! - Prints something without a newline
 ; - Separates commands
===Examples===
The following is a Hello, world! program in g*:
 p Hello, world!
This is a input/output example:
 ? 1;@ 1
This is an example of a loop:
 l 5 p Hello, world!
===Interpreters===
A python interpreter of G* can be found at GitHub (dead link)
Category:Languages Category:2015 Category:Golfing language
GDLang

GDLang is a 2-dimensional esolang written an interpreted entirely in Geometry Dash. No external tools are used; you edit and run the program within the game's editor.
== GDLang ==
=== Memory and output ===
Since an actual memory model like a stack is very difficult, GDLang uses 4 registers, three for storage and one for output.
=== Instruction writing ===
Each instruction is a collision block (CB). Copy and paste the corresponding CB to the codebox so it can be ran over an instruction pointer (IP) and be executed.
GEMROOTD

Let GEMROOTD be a variant of Gemooy with the following modifications.
The symbols $ and % have been eliminated; instead, the presented playfield must have an odd number of symbols in each dimension, and the instruction pointer and data pointer are both considered to start at the center of the playfield.
We establish complete freedom of choice in the matter of the remaining symbols in the following manner.
* The most frequently used symbol in the playfield is treated as equivalent to Gemooy's blank space. 
* The second most frequently used takes the place of @.
* The third most frequently used takes the place of #. (In the case where a program actually requires more #-type symbols than @-type symbols, unused dummy @-type symbols which are never executed may of course be introduced.)
* If the outer edges of the program consist of a fourth symbol which is used nowhere inside those edges, they are considered to denote a border. The playfield is then considered to be fixed; it consists of everything inside the border, and only ever that; it cannot expand dynamically as the program executes. Attempts for either of the pointers to move beyond the fixed area thus established cause the pointer to wrap around to the corresponding location on the other side.
* The meaning of the presence of more than 4 different kinds of symbols is undefined and reserved for future expansion.
GEMROOTD was designed in April 2011 based on experiences with a visual art project based on Gemooy.
Category:Languages Category:Two-dimensional languages Category:Self-modifying Category:2011 Category:No IO Category:Unimplemented
GERMAN

GERMAN was created in 2014 by User:domi382 and it is a member of the TrivialBrainfuckSubstitution family of programming languages.
GERMAN 	Brainfuck
LINKS 	<
RECHTS 	>
ADDITION 	+
SUBTRAKTION 	-
EINGABE 	,
AUSGABE 	.
SCHLEIFENANFANG	[
SCHLEIFENENDE 	]
Category:Brainfuck equivalentsCategory:2014Category:LanguagesCategory:PseudonaturalCategory:Cell-basedCategory:Brainfuck derivativesCategory:Turing completeCategory:Turing tarpits
GHOST

== GHOST ==
GHOST (Ghost holes of spoon tables) is a programming language developed by nalaek2004 in 2015. The language is small, and cannot contain variables. It also has no IO.
There are 3 commands in the language:
*CREATE PERSON
*KILL PERSON
*REVIVE PERSON
== Description ==
The interpreter has 2 values:
*Dead
*Alive
Dead is the amount of dead people, and Alive is the amount of alive people.
== Examples ==
=== A simple counter ===
 CREATE PERSON
 CREATE PERSON
 CREATE PERSON
 CREATE PERSON
 CREATE PERSON <- Repeat infintely
=== Addition ===
 CREATE PERSON
 CREATE PERSON
 CREATE PERSON
 CREATE PERSON
 CREATE PERSON
 CREATE PERSON
 KILL PERSON
 KILL PERSON
 REVIVE PERSON
 REVIVE PERSON
This program uses the Dead and Alive values to add.
=== Subtraction ===
 CREATE PERSON
 CREATE PERSON
 CREATE PERSON
 CREATE PERSON
 CREATE PERSON
 CREATE PERSON
 CREATE PERSON
 CREATE PERSON
 CREATE PERSON
 CREATE PERSON
 CREATE PERSON
 CREATE PERSON
 CREATE PERSON
 CREATE PERSON
 CREATE PERSON
 CREATE PERSON
 KILL PERSON
 KILL PERSON
 KILL PERSON
 KILL PERSON
 KILL PERSON
 KILL PERSON
== Interpreters ==
Scratch GHOST interpreter by nalaek2004 Interpreter
Category:Languages
Category:2015
Category:Implemented
Category:Total
GHost CPU

GHost CPU (GHC) is one of the languages used in the ICFP contest 2014. 
GHC is designed to resemble an 1980s 8-bit microcontroller. It has a read-only code memory made of 256 instructions, a read-write data memory made of 256 bytes, 8 general-purpose registers of one byte size each, and a program counter. The instructions all operate on one-byte values. The instructions include copy, add/subtract (modulo 256), bitwise and/or/xor, unsigned less/greater/equal compare and branch if the comparison is true, multiplication (low byte of result only), unsigned division (quotient only), or operating system call. The arithmetic instructions are read-modify-write style, as in, the output argument is always the same as the first input argument (the divisor for divison, the input that is not negated for subtraction). Each input or output argument can be one of the eight general registers, the memory byte at a fixed address, the memory byte at the address given by one of the general purpose registers (with no offset), or, for input arguments only, a constant byte or the program counter. In addition, for only the copy instruction, the output argument can be the program counter too, thus allowing an indirect jump. The compare and branch instructions branch to a fixed address in the instruction memory. The operating system interface use fixed registers as input or output, but which registers mean what depends on the specific system call.
In the story of the contest, the LamCo company used this language to control the ghost AIs in their arcade computer running a Pacman-like game. There is a separate instance of GHC for each ghost, each ran by a separate microcontroller on the motherboard of the machine. The operating system call instruction of these GHCs is wired up to interact with the Pacman-like game, as in, read information about the map and state of Pacmans and ghosts, and set the direction that the ghost is walking towards.
== External links ==
* Contest homepage
* Language specification
Category:Languages
Category:2014
Category:Cell-based
Category:ICFP contest
Category:Programming games
GML

:Not to be confused with Game Maker Language, a non-esoteric language developed by Yo Yo Games Ltd.
GML is the programming language defined for ICFP contest 2000. The goal of the contest is to implement a ray tracer. The GML language is thus used to describe a scene as input to the raytracer. The description of the language is available in HTML, PDF and postscript format.
GML is a simple pure functional language with syntax somewhat similar to postscript. It has an argument stack and an implicit execution stack. It has lambda syntax that creates functions with read-only variables bound to names. Types of values supported are: boolean, integer, floating point number, point (triples of floats), read-only array containing arbitrary values, function (closure), object, light. 
The objects are built using constructive solid geometry. The base objects are sphere, cube, cylinder, plane. The texture of a base object is defined by a "surface function", a GML function that takes surface coordinates as input and returns the color and texture properties at that point of the surface. Objects can be transformed and combined with union, intersection and difference operators. GML has an operator to render a ray-traced image from objects and lights, so a single program may generate any number of images by calling the operator in a loop. 
Category:Turing complete
Category:Output only
Category:Stack-based
Category:ICFP contest
Category:2000
Category:Languages
Category:Functional paradigm
GOTO 10

GOTO 10 is a programming language with only GOTO statements.
Execution starts on the line(s) with the line number 10.
== Syntax ==
A program is a collection of lines. Lines beginning with REM are
comments. Otherwise, a valid line consists of a line number, GOTO, an
expression, and an optional WITH clause, consisting of WITH and an
expression.
Spaces are ignored, so the following lines are valid and equivalent:
 10 GOTO 10
 10GOTO10
 10 GO TO 1 0
 1 0 G OT O10
 0000010 GO TO 010
== EBNF grammar ==
 program = { line, "\n" } ;
 line = comment-line | goto-line ;
 comment-line = [ number ], "REM", { ? non-newline character ? } ;
 goto-line = number, "GOTO", expression, [ "WITH", expression ] ;
 number = digit, { digit } ;
 digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" ;
 expression = number
 | ( "I" | "N" ), [ "(", expression, ")" ]
 | expression, "+", expression
 | expression, "-", expression
 | expression, "*", expression
 | expression, "/", expression
 | "(", expression, ")" ;
== Execution ==
Execution is done by a number of threads in discrete steps, with each
thread executing a single GOTO statement simultaneously in a step.
If the target of a GOTO statement does not exist, the thread executing
it dies. If all threads die, execution stops.
If there are multiple lines with the line number targeted by a GOTO
statement, the thread executing it forks, with one thread per target
for the next step.
The WITH clause causes the total number of threads going to the target
line from the given line to be the value of the WITH expression
instead of the number of threads executing the given line. So a GOTO
statement without a WITH clause is equivalent to one with a WITH N
clause.
== Expressions ==
Expressions are integer expressions. The +, -, *, / are the
conventional integer addition, subtraction, multiplication, and
division operators. Division by zero results in a run-time error that
stops execution.
The special symbol I reads input. I evaluates to the next bit of
input, while I(x) evaluates to the next x bits of input as a
little-endian integer. If x <= 0, I(x) = 0. At EOF, I = -1 and I(x)
= -1. If x is greater than the number of input bits remaining, I(x)
evaluates to the remaining input bits.
The special symbol N is the number of threads executing the
statement, and N(x) is the number of threads that came from line x.
On the initial execution of line 10, N = 1, and N(x) = 0.
== Output ==
At each step, if the number of threads going to line 0 is greater than
0, then that number minus 1 is output as little-endian bits.
== Examples ==
=== Hello world ===
 10 GOTO 20
 10 GOTO 0 WITH 6379151218083139189807317952019
 20 GOTO 0
=== cat ===
 10 GOTO 0 WITH I+1
 10 GOTO 10 WITH I+1
== External resources ==
* Implementation
Category:Languages
Category:2015
Category:Unknown computational class
Category:Implemented
GP

== GP (also known as GPLang) ==
GP (also known as GPLang) is an esoteric programming language created by Slendi meant to be as degenerate as possible. It replaces every operator and literal in programming languages with more perverse and convoluted ones.
=== Literals ===
Integers can be specified using the dick operator. The length is the value.
Example:
8=====D " has the value of 5. "
8D " has the value of 0. "
Strings can be written like this, they are not multiline:
/*This is a string*/
=== Math operations ===
Addition: :3
Subtraction: >:3
Multiplication: uwu, UWU, UwU, uwU, Uwu, UWu, uWU
Division: owo, OWO, OwO, owO, Owo, OWo, oWO
Modulo: :P
=== Conditionals ===
(.Y.) condition Nya!
 "code to exekawaii~ w-when weaw~~"
nya~ UOOOOOOHHHH Nya!
 "c-code to exekawaii~ when fake~~"
nya~
=== While loop ===
aaa >///< 8=====d~~
(_Y_) aaa Nya!
 sum >///< sum :3 sum~~
 a-aaa >///< aaa >:3~~
nya~
=== Functions ===
Please note the language only has global scope, so the arguments with the names specified will be overwritten.
😭😭😭😭😭😭 function_name(arg1, arg2, arg69) Nya!
 arg1 :3 arg2 :3 arg69~~
nya~
function_name(8=D, 8==D, 8====D)~~ "arg1, arg2, arg69 are set globally"
=== External resources ===
* The official GP compiler
Category:Languages Category:Implemented Category:Thematic
GPRX 3000

GPRX 3000 is an esoteric programming language invented by xfix in 2016 implemented on non-existent GPRX 3000 CPU with three arbitrary precision registers and no external memory support.
== Overview ==
GPRX 3000 programs are ran from beginning to end. All three general purposes registers and program counter are initialized to zero at program start. CPU implements the following commands.
Command	Description
+ 	Adds contents of register B to register A.
- 	Subtracts contents of register B from A, and assigns the result to A. Throws an exception if a result is negative, as GPRX 3000 CPU doesn't support negative integers.
* 	Multiplies contents of register A and B, and sets the result to A.
/ 	Divides contents of register A by B, and sets the result to A.
% 	Performs modulo operation of register A using B, and assigns the result to A.
g 	Sets the program counter to contents of register A. This instruction doesn't cause program counter to increment after a jump. Throws an exception if program counter would be outside of program.
p 	Sends a current byte from register A to I/O port, which on emulator means standard output.
r 	Reads a byte from I/O port, increments it by 1, and sets it to register A. On error, 0 is returned. On emulator reading means reading from standard input.
x 	Sets register A to be register C, register B to be register A, register C to be register B.
Additionally, you can type in decimals in order to assign them to register A.
All other characters including whitespace throw an exception when executed, due to programs being supposed to be ran on CPU (subject to change).
== Examples ==
Those programs assume themselves ending with a newline, as language throws an exception when GOTO instruction goes beyond the end of a program.
=== Hello, world! ===
 72p101p108pp111p44p32p119p111p114p108p100p33p10p51g
=== cat ===
 rx1+x1/x5*xx+xx2x-xx24+gxp0g
== Computational class ==
GPRX 3000 is Turing-complete as it can emulate an iterated Collatz function.
For a function given by
 f(mx+i) = aix + bi, i=0..m-1,
at program position X, put the code
 xx0+xmx%xxDx*xxSx+g
and at program positions Di+Y, i=0..m-1,
put
 mx/xai*xbi+xxXg
for a remainder that continues or
 mx/xai*xbi+xxZg
for a remainder that halts.
X is the entry point of the loop, Z where it should jump when halting, and D and Y may be chosen as whatever makes the parts fit into the program.
== External resources ==
* Reference emulator
Category:Languages
Category:2016
Category:Turing complete
Category:Low-level
Category:Implemented
GS

GS is an esolang invented by User:None1, it is C#, but changed to be suitable for golfing.
==Features==
===using===
All the namespaces are automatically using-ed, so you don't have to do that explicitly, if two namespaces have the same identifiers, the one in the lexicographically smaller namespace is chosen.
===if statements===
In normal C#, if statements doesn't support types other than boolean, but in GS, other types are automatically converted to boolean in if-statements.
===Golfed names===
These are the names that are golfed in GS:
 Console.Write -> cw
 Console.WriteLine -> cl
 Console.Read -> cr
 Console.ReadLine -> cs
 Console.ReadKey -> ck
 Convert.ToInt32 -> Ci
 Convert.ToInt64 -> Cl
 Convert.ToChar -> Cc
 Convert.ToString -> Cs
 class -> c
 struct -> s
 interface -> i
 enum -> e
 delegate -> d
 record -> r
 event -> E
 static -> S
 readonly -> R
 const -> C
 volatile -> v
 override -> o
 virtual -> V
 abstract -> a
GUI4BF

GUI4BF, or GUI for Brainfuck, is an esoteric brainfuck library (or, technically, a derivative, as BF doesn't support libraries) that supports Graphical User Interfaces, as well as a few useful features added for GUI simplicity (such as functions for callbacks). The idea is still in idealizing.
== Project may be abandoned ==
I (User:DmilkaSTD) realized that this page has been abandoned for 5 years. Feel free to continue the project, or contact its creator (User:Hppavilion1) and help him.
Category:Languages Category:Brainfuck derivatives Category:2015 Category:Unimplemented
G Sharp

G# is a esolang with the syntax similar to Python and C. Created by User:Ractangle
== Syntax ==
===Commands===
Command 	It's action
make <classname>;[...] 	Creates a class,
print <string> 	Prints a string.
assign <varname> as <varval>	Creates/Edits a variable.
loop if <condition> 	while statement.
if/else/orif 	Condition command.
input 	Gets user input
# 	One-line comment
###...### 	Multi-line comments
return 	turns a class into a function
===Classes===
A Class should folow this structure:
 make a_name_here;[
 # Commands here
 ]
===Variables===
The variables NEED to be assigned at the top.
Also there are types:
Type name	Type symbol
String 	$
Integer 	#
Boolean 	?
Ticker 	+
And if you want to edit a variable. You just write:
 assign $a to anything
And if you want to assign more variables with the same value, write:
 assign a;b to anything
This implies to the variable edition as well
===Functions===
Functions are basically the same as Classes. "But how do make functions?" you may ask.
Simple. Just add a return command and some arguments:
 return {written}{like}{this}
And to use the argument on a function, We just write:
 f[name]{the argument used in your function}
So the function should look like this:
 make function; [
 return {arg}{another arg}
 # Commands here
 ]
And to call a function:
 f[function]{Hello, ||world!}
And now you're probably saying, "So if an argument is used, it's automatically an required argument, right?"
Yes, but you can turn off the "require" option if it's not really required:
 make fun [
 return{arg#r=0}
 # Commands here
 ]
Also fun fact:If there are no classes but only functions, the program will run the latest declared function, argument are automatically ignored (if the command-line args for those args not added)
===Errors===
If no main class is found in the code:
 NO MAIN CLASS FOUND IN CODE
If a built-in function gets overwritten by another function:
 CANNOT OVERWRITE BUILT-IN
== Examples ==
=== Hello World ===
 make main;[print("Hello World\n")]
===Cat program===
 string assign a as input
 make main;[print($a)]
===A+B problem===
 integer assign a;b as input
 make main;[print(#a+#b)]
===Infinite loop===
 boolean assign l to 1
 make main;[ loop if 1 [1] ]
===Truth-machine===
 integer assign i as input
 make main;[
 if #i=0 [print(0)]
 loop if 1 && #i!0 [print(1)]
 ]
===Empty Program===
 make e; [return{}]
===99 bottles of beer===
 integer assign bot as 99
 make main;[
 if #bot is 1;[ print(#bot," bottle of beer on the wall,\n",#bot," bottle of beer.\nTake one down, Pass it around,\nNo bottles of beer on the wall,\n") ]
 else [ loop if #bot ! 1;[ print(#bot," bottles of beer on the wall,\n",#bot," bottles of beer.\nTake one down, Pass it around,\n");assign #bot as #bot-1;print(#bot," bottles of beer on the wall,\n\n") ] ]
 ]
Category:LanguagesCategory:2024Category:High-levelCategory:Unimplemented
Gabor de Mooij

Gabor de Mooij is a professional software developer who lives in the Netherlands. He studied Cognitive Psychology, User Interface Design and Artificial Intelligence at Leiden University. In 2000, 2001 he created a series of games including the Midnite Motel and the Blue Lady which were bundled with several magazines and sold on shareware CD-ROMS. He also developed the MechaniQue programming language, an esoteric programming language for interactive fiction.
==External resources==
*Personal homepage
Category:People